Jump to the full History here

Jump to the English essay here.

J.Konstapel,Leiden, 1-11-2026.

Used blog: The Vacuum.Net Theory

Computing on the Net: van abacus tot sluitingsregister

1. De vraag

Wat is een berekening?

Lang leek het antwoord vanzelfsprekend. Een berekening is een procedure. Je geeft invoer. Je volgt vaste stappen. Je krijgt uitvoer.

Eerst deed men dit met de hand. Daarna met tandwielen. Daarna met schakelaars.

Dit essay vertelt die geschiedenis. Het volgt ook een tweede lijn. In 2026 verscheen een boek van J. Konstapel. Dat boek leest de hele computing door één nieuwe lens: de Vacuum.Net-theorie.

De kern is kort. Een berekening is geen reeks instructies. Een berekening is een pad. Het pad eindigt wanneer het sluit. Wat sluit, laat alleen een overdracht achter. Sluiting is de stopregel. Niet een halt-opdracht.

Het boek is voorzichtig met bewijs. Elke bewering krijgt een statuslabel. Historisch feit. Bewezen. Berekend. Correspondentie. Hypothese. Open.

Dat is belangrijk. De correspondenties kunnen falen. Het boek zegt dat zelf.

2. Vóór de machine: procedure, tekens en overdracht

Drie ideeën zijn ouder dan de computer.

Het eerste is de procedure die eindigt. Euclides beschreef rond 300 v.Chr. een algoritme voor de grootste gemene deler. Herhaald aftrekken. Stoppen wanneer de rest nul is.

In de taal van het net is dit de oudste sluiting. De run eindigt waar de rest nul wordt.

Het tweede is de combinatie van tekens. Ramon Llull bouwde rond 1305 draaiende papieren schijven. Enkele begrippen werden tegen elkaar gedraaid. Zo ontstonden alle paren.

Leibniz ging verder. Zijn calculus ratiocinator stelde redeneren voor als rekenen. Hij koos ook binaire rekenkunde. In 1703 publiceerde hij over grondtal 2.

Zijn ontwerpprincipe was maximale rijkdom uit minimale middelen. Toch ligt volgens de radix-economie grondtal 3 dichter bij het optimum e. De waarden zijn ongeveer 2,731 tegen 2,885 per eenheid ln N. Leibniz koos dus volgens de theorie het verkeerde grondtal.

Het derde idee is de overdracht. Wilhelm Schickard bouwde in 1623 een rekenklok. Blaise Pascal volgde in 1642 met de Pascaline.

Beide machines mechaniseerden één regel. Wat een positie niet kan houden, geeft ze heel door aan de volgende positie. Elke optelmachine daarna is een apparaat voor die regel.

Twee figuren verdienen extra aandacht.

Thomas Fowler bouwde in 1840 een rekenmachine in gebalanceerd ternair. Hij rekende in de notatie van het net. Dat was 118 jaar vóór de Sovjet-Setun.

Ada Lovelace publiceerde in 1843 het eerste programma. Het berekende de Bernoulli-getallen. Zij zag ook dat symbolen verder kunnen gaan dan getallen.

George Boole sloot het tijdperk af. In 1854 gaf hij de logica een algebra met twee waarden: 0 en 1. Het net werkt met drie waarden.

Een twee-waardig register heeft geen waarde die verschilt van haar omkering. Dat gat is volgens het boek geen detail.

3. 1936: vier definities, één idee

1936 is het scharnier van de geschiedenis. Vier onafhankelijke definities van “berekenbaar” verschenen tegelijk.

Church gaf de λ-calculus. Turing gaf de Turingmachine. Post gaf een werker die tussen gemarkeerde dozen beweegt. Kleene gaf de μ-recursieve functies.

Alle vier bleken dezelfde klasse van functies te definiëren. De Church-Turingthese zegt: deze klasse is alles wat een procedure kan berekenen.

Dit waren geen abstracte spellen. Zij beantwoordden Hilbert’s Entscheidungsproblem uit 1928. Bestaat er een procedure die elke uitspraak van de eerste-orde-logica beslist?

Gödel had in 1931 de grondvesten geschud met zijn onvolledigheidsstellingen. Church en Turing gaven daarna het verdict. Zo’n procedure bestaat niet.

Het net leest deze geschiedenis met belangstelling. Gödel en Church steunen beide op een vorm die naar zichzelf verwijst.

Het net doet dat ook. Het eerste axioma wortelt in re-entry. Dat is de mark die zichzelf bevat.

Turing’s tape is een streng met een kop. Het verschil is de stopregel. Turing’s tape heeft geen sluitingsvoorwaarde. Een run stopt alleen wanneer een halt-toestand van buiten komt.

In het net eindigt een run waar zijn vensters sluiten.

Het halting-probleem wordt zo een sluitingsuitspraak. Geen procedure beslist vooraf of elk pad sluit.

Het boek noemt nog een opvallende parallel uit 2026. In een grote studie naar LLM-agenten kon geen model uit de taakbeschrijving voorspellen welk inspanningsniveau de taak zou sluiten. Dezelfde onbeslisbaarheid, waargenomen op agentschaal.

4. De drager, de bit en twee biologische modellen

Tussen 1937 en 1948 kreeg computing een fysiek lichaam.

Claude Shannon toonde in 1937 dat Booleaanse algebra relaisschakelingen beschrijft. Konrad Zuse bouwde in 1941 de Z3 in Berlijn. Colossus kraakte codes met vacuümbuizen in Bletchley Park. ENIAC volgde in 1945 met ongeveer 17.500 buizen.

Hier maakt het boek een scherp historisch punt. Het binaire tijdperk volgde uit de drager, niet uit de wiskunde.

Een relais of transistor heeft twee stabiele toestanden. Shannon’s informatietheorie gaf in 1948 de bit als maat voor onzekerheid. De twee-waardige schakelaar en de bit sloten op elkaar aan.

Gebalanceerd ternair is nooit weerlegd. Het had alleen geen drager met drie stabiele toestanden.

Twee biologische modellen verschenen in dezelfde periode.

McCulloch en Pitts beschreven in 1943 het drempelneuron. Norbert Wiener publiceerde in 1948 Cybernetics. Feedback werd het centrale mechanisme.

Het net claimt beide als verwanten. Het neuron sluit wanneer zijn som een drempel overschrijdt. Het net sluit wanneer zijn som nul is modulo 3.

Beide zijn somregels. Het neuron gooit het teken weg. Het net houdt de rest en geeft de overdracht door.

Wiener’s feedback is de memory-axioma van het net in technische vorm. Elke correctie gebeurt ten opzichte van een setpoint.

5. Twee architecturen van von Neumann

John von Neumann gaf computing twee architecturen. We leven in de eerste.

De opgeslagen-programmacomputer werd in 1945 voor EDVAC ontworpen. Programma en data kwamen in één geheugen. Manchester’s Baby liep op 21 juni 1948 het eerste opgeslagen programma. EDSAC leverde in 1949 de eerste praktische dienst.

De prijs is de von Neumann-bottleneck. Elke stap leest opnieuw uit het geheugen via één kanaal.

Het boek maakt een moderne observatie. LLM-agenten hebben dezelfde bottleneck op grotere schaal. Elke aanroep leest de hele gespreksgeschiedenis opnieuw.

De gemeten invoerkosten groeien als n^1,82 tot n^1,92 in het aantal aanroepen. Exponent 2 is de signatuur van volledige geschiedenis. De metingen zitten net daaronder. Caching verklaart het gat.

De tweede architectuur was de cellulaire automaat. Von Neumann ontwikkelde die met Stanisław Ulam. Publicatie volgde postuum.

Computing werd verspreid over ruimte. Alleen lokale regels gelden. Conway’s Game of Life volgde in 1970. Wolfram’s elementaire automaten volgden. Cook bewees in 2004 dat Rule 110 universeel is.

Hier wordt de theorie technisch. De kernrewrite van het net is:

R(t)i = −(t(i−1) + t(i+1)) mod 3.

Dat is een eendimensionale cellulaire automaat. Drie toestanden. Radius-1-buurt. Additief. Lineair over Z₃.

Additieve automaten zijn volledig beschreven door polynomiale algebra. Ze zijn op zichzelf niet universeel. Dat is een bewezen beperking.

Het net wordt niet-lineair door de overdracht tussen schalen. c(1) + c(1) = 0. Maar c(1 + 1) = 1.

Of rewrite plus overdracht plus geheugen universeel is, blijft open. Het boek zegt dat duidelijk.

6. Kosten, betekenis en interactie

Na 1950 verfijnden drie vragen het veld.

Wat kan eindig geheugen doen? Kleene’s reguliere gebeurtenissen en Chomsky’s grammaticahiërarchie sorteerden talen naar geheugen. Geen geheugen. Stack. Begrensde tape. Onbegrensde tape.

Rabin en Scott formaliseerden eindige automaten. Het net leest Chomsky’s niveaus als niveaus van geheugen in de vorm van het pad.

Een pad waarvan alle vensters sluiten, heeft alleen het laatste venster nodig. Dat zijn negen mogelijke toestanden. Een eindige automaat.

Wat kost berekening? Hartmanis en Stearns stichtten in 1965 de complexiteitstheorie. Cook, Karp en Levin stelden rond 1971 NP-volledigheid vast.

Solomonoff, Kolmogorov en Chaitin definieerden algoritmische informatie. De complexiteit van een string is de lengte van zijn kortste programma. Chaitin’s Ω is welgedefinieerd maar niet berekenbaar.

Het net neemt Chaitin als vergelijkingsmaat. Een theorie is een programma dat korter is dan zijn data. Het boek telt de axioma’s van elke rivaliserende theorie in deel XIV op die basis.

Wat betekent een programma? Scott en Strachey’s denotationele semantiek gaf het antwoord. Een recursieve definitie betekent het kleinste dekpunt van een continue functie.

De Curry-Howard-correspondentie identificeerde programma’s met bewijzen. Martin-Löf bouwde intuïtionistische typetheorie. Dat is de basis van Lean en Coq. Homotopie-typetheorie leest gelijkheid als een pad tussen punten.

Het net claimt verwantschap met al deze theorieën. Een bewijs is een pad dat sluit. Een type zonder gesloten pad is een propositie zonder bewijs. Het dekpunt is de eigenvorm.

Het verschil: deze theorieën nemen een onbeperkte voorraad stappen aan. Het net telt de kosten van elke stap.

Concurrencytheorie maakte de trace centraal. Dat is het geordende verslag van gebeurtenissen. Petri-netten, het actor-model, Hoare’s CSP en Milner’s π-calculus beschrijven patronen van uitwisseling.

Het net leest dat direct. De trace is de streng. Synchronisatie is een ontmoeting die sluit. Milner’s kanaalmobiliteit is de overdracht. Een gesloten uitwisseling wordt één passage op de volgende schaal. Die passage is zelf doorgeefbaar.

Het verschil is kosten. Geen van deze theorieën telt de kosten van het dragen van de trace. In de praktijk groeit die zonder limiet. Het net sluit haar en houdt alleen de overdracht.

7. De fysica: wissen heeft een prijs

Vanaf 1961 werd computing een fysiek proces met een energierekening.

Landauer’s principe: één bit wissen kost minstens kT ln 2 aan warmte. Bennett toonde in 1973 dat elke berekening logisch omkeerbaar kan worden. Dat kan als je de geschiedenis bewaart.

Omkeerbare poorten, quantumcomputing en analoge modellen volgden. Shor’s factorisatiealgoritme kwam in 1994. Google’s Sycamore claimde in 2019 quantum supremacy met 53 werkende qubits.

Het net positioneert zich precies hier. Wissen heeft een adres: de sluiting. Een venster dat sluit, is waar informatie het pad verlaat.

Bennett’s omkeerbare computer bewaart alles en betaalt geen warmte. Maar de leeskosten worden kwadratisch. De full-history LLM-agent is Bennett’s machine op agentschaal.

Het net zit tussen de uitersten. Het houdt de overdracht. Het wist het geslotene. Het goedkope geheugen wordt gekocht met wissen. Wissen kost warmte. Er is geen gratis lunch, alleen een gekozen prijs.

8. Sluiting: de traditie achter de theorie

Een aparte traditie, grotendeels buiten de computerwetenschap, maakte sluiting centraal. De Vacuum.Net-theorie stamt daarvan af.

Rosen’s (M,R)-systemen beschreven organismen die gesloten zijn onder efficiënte causaliteit. Simon’s Architecture of Complexity vertelde de horlogemakerparabel.

Tempus bouwt het hele horloge tegelijk. Bij elke onderbreking verliest hij alles. Hora bouwt stabiele deelassemblages. Hij verliest alleen het deel in zijn hand.

Spencer-Brown’s Laws of Form tekende de onderscheiding en de re-entry. Maturana en Varela noemden autopoiesis. Von Foerster definieerde eigenvormen: een stabiel object is het dekpunt van een recursieve operatie. Kauffman formaliseerde dit als O(A) = A.

Rowlands en Diaz bouwden een rewritesysteem dat vanaf nul begint. Het genereert de algebra van de fysica.

Het net claimt Spencer-Brown en Kauffman als verklaarde grond. Het voegt rekenkunde toe aan hun meetkunde.

De mark wordt een trit. Re-entry wordt een terugkeer van de streng. Sluiting wordt een som die nul is modulo 3. Simon’s horlogemaker wordt de overdracht: houd de gesloten deelassemblages, verlies alleen het open venster.

9. De weg niet genomen: ternaire computing

Gebalanceerd ternair gebruikt cijfers −1, 0 en +1. Het is twee keer op schaal gebouwd.

Fowler’s houten machine in 1840. Brusentsov en Sobolev’s Setun aan de Staatsuniversiteit van Moskou in 1958. Ongeveer vijftig Setun-machines werden in Kazan gebouwd. Donald Knuth noemde gebalanceerd ternair later “misschien wel het mooiste getallensysteem van allemaal”.

Waarom verloor het? De schakelaar heeft twee stabiele toestanden. De Setun haalde drie toestanden uit paren ferrietkernen. Het obstakel was de drager, niet de rekenkunde.

Gebalanceerd ternair heeft vier eigenschappen die geen andere radix-3-notatie heeft. Geen minteken. Carry-vrije vermenigvuldiging met één trit. Afkappen is gelijk aan afronden. Schakelen is gelijk aan een schaalstap.

Het komt terug. In 2019 bouwde Kim Kyung Rok bij UNIST, gefinancierd door Samsung, ternaire CMOS op een volledige siliciumwafer. De derde toestand kwam uit een tunnellingstroom. Huawei diende een patent in voor een ternaire poort. Publicatie volgde in maart 2025.

Microsoft Research’s BitNet b1.58 toonde in 2024 dat een groot taal模型 zijn kennis kan dragen in gewichten van {-1, 0, 1}. Dat is het trit-alfabet in software. De naam telt log₂ 3 ≈ 1,58 bits per gewicht.

Maar geen ternair apparaat had ooit de sluitingsregel als hardware-operatie. Die observatie zet het voorstel van het boek in deel XV op.

10. De empirische anker: wat inspanning werkelijk koopt

Het empirische anker is een studie uit 2026 van Sun et al. What Effort Level Should I Choose? On the Economics of Reasoning Effort in LLM Agents.

De studie testte acht modellen op vier benchmarks. De bevindingen zijn belangrijk.

• Op taken die elk inspanningsniveau oplost, kostte de hoogste inspanning tot 42× de laagste.
• Op een software-engineeringbenchmark kostte lage inspanning $0,27 per taak. De hoogste kostte $1,24, met bijna dubbel zoveel aanroepen.
• Redeneren uitgeschakeld kostte meer dan lage inspanning: 21,5 tegen 5,4 aanroepen.
• In een gecorrigeerde omgeving verlaagde de hoogste inspanning de oplossingsgraad voor acht van acht modellen.
• Een “ladder”-beleid — eerst laagste inspanning, escaleren na geverifieerd falen — bespaarde 25,3% op AIME, 41,5% op GPQA en 15,5% op de gecorrigeerde benchmark.
• Wachttijd voor de gebruiker was 58–98% van de volledige kosten.

Het net leest deze cijfers als zijn eigen stellingen in het wild. De transformer leest elke stap zijn hele context opnieuw. Dat is de full-history-computer. De kostenexponent ligt bijna op 2.

Redeneren stopt niet vroeg op makkelijke taken. De sluitingstest ligt buiten het pad, bij de evaluator. Het ladder-beleid is de schaalregel: sluit eerst op de laagste schaal. Geef alleen door wat open blijft.

11. De theorie in één zin

Deel XIII formuleert de Vacuum.Net-theorie in één zin. Een berekening is een streng. Zij houdt alleen wat nog niet gesloten is. Zij geeft elke sluiting één schaal hoger door als overdracht. Daarom groeien geheugen en kosten met het aantal ternaire cijfers van het werk, niet met de lengte.

De elementen zijn:

• een streng: één geordend pad van passages;
• een register: elke passage draagt een trit bij, −1, 0 of +1;
• sluiting: een stand, een ontmoeting of een ring — niets anders sluit;
• een overdracht: ringen geven één passage één schaal hoger door;
• een stap: toevoegen, sluiten, overdragen;
• spanning: wat op elke schaal open blijft.

Stelling C1: begrensd open geheugen. Na n passages houdt elke schaal hoogstens twee open passages. Die zijn gelijk. De open passages coderen de lopende som exact. Het aantal bezette schalen is hoogstens ⌊log₃ n⌋ + 1. De totale kosten van het lezen van de open toestand bij elke stap zijn O(n log n). Dat staat tegenover n(n + 1)/2 voor het lezen van de volledige geschiedenis.

Het bewijs is een kort invariantargument. Een toegevoegde 0 is een stand en verdwijnt. Een tegengestelde trit vormt een ontmoeting. Beide verdwijnen. Gelijke trits stapelen tot drie. Dat vormt een ring. De ring verdwijnt en gaat één schaal hoger.

Elke verwijdering behoudt de waarde. De reductie is vermomde gebalanceerd-ternaire optelling. De open toestand is het adres van het gedane werk.

De stelling is computationeel gecontroleerd op stromen van 10³ tot 10⁶ passages. In elke run reproduceerde de open toestand de lopende som exact. Geen schaal hield ooit meer dan twee passages. De leeskosten per stap naderden log₃ n voor all-ring-stromen. Voor random stromen lagen ze ongeveer op de helft. Daar annuleren ontmoetingen als in een random walk.

Hypothese H1: sluiting als compressie. Een agent wiens context alleen open items en overdrachten van gesloten subtaken bevat, zou invoerkosten O(n log n) moeten tonen in plaats van O(n²) in het aantal aanroepen. De gemeten exponent van ongeveer 1,9 zou richting 1 moeten dalen.

De prijs is Landauer’s prijs. De route naar elk gesloten resultaat wordt gewist en kan niet meer worden geïnspecteerd. De voorgestelde test is simpel. Laat één agent twee keer op dezelfde taken lopen: met volledige geschiedenis en met gedragen sluitingen. Meet de exponent.

12. Alle theorieën naast elkaar

Deel XIV plaatst het net eerlijk naast zijn rivalen.

• Turingmachine: de tape is een streng, maar er is geen sluitingsregel.
• λ-calculus: de normaalvorm is een dekpunt, maar er is geen begrensd geheugen.
• Eindige automaten: een overal gesloten pad heeft alleen negen toestanden nodig.
• Petri-netten: de transitie is een lokale sluitingsregel, maar de trace is onbegrensd.
• Omkeerbaar rekenen: bewaart de hele geschiedenis en betaalt geen warmte — de omgekeerde ruil.
• Transformer-agenten: full-history-paden, kostenexponent 1,8–1,9.

Alleen het net maakt sluiting de stopregel. Alleen het net houdt geheugen begrensd door de cijfers van het werk. Alleen het net leidt kosten uit dezelfde regel af.

De anderen hebben één of twee van de drie. Geen enkele heeft alle drie.

Dat is ook het Ockham-argument van het boek. De regel die een run beëindigt, is de regel die haar geschiedenis wist. Diezelfde regel is de regel die resultaten doorgeeft. Eén regel waar de anderen drie nodig hebben.

Wat alle theorieën delen, is even duidelijk. Een resultaat is een configuratie die ophoudt te veranderen.

Turing noemt het halting. Church noemt het normaalvorm. Scott noemt het dekpunt. Petri noemt het dode markering. Rosen noemt het sluiting.

De weddenschap van het net is: één rekenregel — som tot nul modulo 3, draag wat overblijft — genereert al deze vormen.

13. Het voorgestelde apparaat: het sluitingsregister

Elke theorie vond haar apparaat zodra een drager met de juiste native operatie bestond. Tandwielen voor de overdracht. Schakelaars voor Boole. Transistoren voor von Neumann. GPU’s voor attention.

De native operatie van het net is sluiting met overdracht. Nog geen apparaat voert die als één operatie uit. Deel XV stelt er een voor.

Het sluitingsregister is een stapel schalen. Elke schaal houdt hoogstens twee gelijke trits. Elke schaal heeft één detector met drie uitkomsten.

Een stand laat geen spoor. Een ontmoeting wist de opgeslagen trit. Een ring wist de schaal en stuurt één trit omhoog door de overdrachtslijn.

Het register houdt het gebalanceerd-ternaire adres van alles wat erdoor is gegaan.

De grootte is bescheiden. Voor N passages volstaan ⌊log₃ N⌋ + 1 schalen. Voor N = 10¹² zijn dat 26 schalen en 52 tritcellen.

De energieondergrens is Landauer’s. Elke sluiting wist informatie. Eén trit wissen kost minstens kT ln 3 ≈ 4,55 × 10⁻²¹ J bij 300 K. Een CMOS-poort dissipeert vandaag 10⁻¹⁶ tot 10⁻¹³ J. Dat is ongeveer 10⁴,⁵ tot 10⁷,⁵ keer de ondergrens. De ondergrens is echt, maar niet de praktische limiet.

Drie fasen worden voorgesteld.

1. Software: een agent-harnas dat open items plus overdrachten van geverifieerde subtaken houdt. Dat test H1 direct, nu.
2. Digitaal: een FPGA-accumulator, twee bits per trit. Stroom in, adres uit. Standaardonderdelen.
3. Native: ternaire CMOS of memristieve drie-toestandscellen, met sluitingsdetectie als één poort. De dragers voor fase drie zijn tussen 2019 en 2025 gedemonstreerd.

Drie toepassingen springen eruit.

Agentgeheugen: context als register. H1 voorspelt dat de kostenexponent van ongeveer 1,9 richting n log n daalt.

Ternaire neurale rekenkunde: producten van ternaire gewichten en invoer zijn zelf trits. Ze optellen is precies de stroom van het register.

Streaming-grootboeken: credit en debet zijn ontmoetingen. Alleen de balans en zijn open cijfers blijven bewaard.

14. Wat open blijft

Het boek eindigt met vijf vragen die zijn lot beslissen.

1. Universaliteit. Is het register met rewrite, overdracht en first-passage-geheugen Turing-universeel? De rewrite alleen is lineair over Z₃ en aantoonbaar niet universeel. De overdracht is niet-lineair. Een bewijs zou een bekend universeel systeem, zoals Rule 110, tot het net moeten reduceren.
2. De tritregel voor echte traces. Stelling C1 geldt voor elke tritstroom. Voor een agent moeten de trits uit de trace worden gelezen door de tritregel. Niet met de hand toegewezen. Zonder dat blijft de correlatie met de LLM-bevindingen een correspondentie, geen stelling.
3. H1 in de praktijk. Verlaagt het vervangen van gesloten subtaken door overdrachten de exponent van ongeveer 1,9 richting 1, zonder de oplossingsgraad te verlagen?
4. Gelijke blokken. Stelling C1 heeft geen gelijke blokken nodig. Ladder-beleid wel. Hoe gemengde ontmoetingen en ringen de kostenwet veranderen, is open.
5. De native drager. Kunnen ternaire CMOS of memristieve cellen sluitingsdetectie als één poort uitvoeren? En tegen welke energie boven de Landauer-ondergrens?

De methode van het boek is zijn beste argument. Alle 74 historische beweringen zijn op 1 november 2026 in vier rondes tegen onafhankelijke bronnen gecontroleerd. De catalogus van 742 entries is gebouwd met een respondent–judge-protocol. 796 kandidaten. Elf juryleden. 95 correcties. Nul verwerpingen. Een tweede jury controleerde 113 entries opnieuw. Elk getal in het boek is met code herberekend.

15. Conclusie

De geschiedenis van computing wordt meestal verteld als een verhaal van steeds snellere machines. Dit boek vertelt het anders.

Elke era had een drager. Tandwielen voor de overdracht. Schakelaars voor Boole. Transistoren voor het opgeslagen programma. GPU’s voor attention.

Elke theorie vond een stopregel van buiten: een halt-toestand, een normaalvorm, een evaluator.

De Vacuum.Net-theorie stelt een omkering voor. Laat de stopregel binnen de berekening leven. Laat sluiting beslissen wanneer een pad eindigt. Laat de overdracht beslissen wat overleeft.

De beloning is geheugen dat groeit met de cijfers van het werk, niet met de lengte. Een O(n log n)-agent in een wereld van O(n²)-geschiedenissen.

Of de weddenschap loont, hangt af van de open problemen. Universaliteit is onbewezen. De tritregel voor echte traces is ongeschreven. H1 is ongetest.

Maar het voorstel is falsifieerbaar. De geschiedenis is gecontroleerd. De rekenkunde is geverifieerd. In een veld dat graag speculeert, is dat een zeldzame en zakelijke combinatie.

Het sluitingsregister wordt misschien nooit gebouwd. De vraag die het stelt — wat moet een berekening onthouden? — zal niet verdwijnen.

Geannoteerde referentielijst

Hieronder een selectie van de belangrijkste werken uit het boek en dit essay. De notities geven kort inhoud en rol in het argument.

Bronnen van het boek

• Konstapel, J. (2026). Computing on the Net: The History of Computing and the Vacuum.Net Theory. Constable Research, Leiden.
  Het bronboek voor dit essay. 134 pagina’s. Plaatst bekende theorieën naast een theorie uit de Vacuum.Net-theorie. Eindigt met een voorgesteld apparaat. Elke bewering heeft een statuslabel. Alle getallen zijn met code herberekend.
• Konstapel, J. (2026). The Vacuum.Net Theory, Ninth Edition: Foundations 9.2 and Physics 9.0. Constable Research, Leiden.
  De moedertheorie. De computingtheorie rust op vier elementen: streng (N1), sluiting (N2), geheugen (N3), schaal met overdracht (N5, T7.1). Niet openbaar geïndexeerd.
• Sun, K., Kwon, Y., Hasan, Z., Zhu, S., Zhou, K., Bianchi, F. (2026). What Effort Level Should I Choose? On the Economics of Reasoning Effort in LLM Agents. arXiv:2610.34491.
  Het empirische anker. Acht modellen, vier benchmarks. Meet kostenexponenten van ongeveer 1,82–1,92. Toont falen van hoge inspanning in gecorrigeerde omgevingen. Toont besparingen van ladder-beleid. Het net leest dit als sluiting en overdracht op agentschaal.

Oudheid tot negentiende eeuw

• Euclides (ca. 300 v.Chr.). Elementen, Boek VII.
  Algoritme voor de grootste gemene deler. Herhaald aftrekken tot de rest nul is. De oudste procedure met een expliciete eindconditie. In het net: sluiting in oudste vorm.
• Llull, R. (ca. 1305). Ars Magna.
  Draaiende papieren schijven combineren begrippen tot alle paren. Vroeg mechanisch schema voor het genereren van tekenscombinaties. Voorloper van redeneren als mechanische operatie op symbolen.
• Schickard, W. (1623). Rekenklok.
  Eerste bekende mechanische rekenmachine met automatische overdracht. Tandwielen. Toont dat de overdracht bouwbaar is.
• Pascal, B. (1642). Pascaline.
  Decimale optelmachine met overdracht over wielen. Bewees de praktische en commerciële kant van mechanisch rekenen.
• Leibniz, G. W. (1672–1703). Stepped reckoner; “Explication de l’Arithmétique Binaire” (1703).
  Bouwde een rekenmachine met getrapte trommel. Publiceerde binaire rekenkunde. Stelde de calculus ratiocinator voor: redeneren als rekenen. Zijn criterium — maximale rijkdom uit minimale middelen — is de vergelijkingsmaat van het boek. Radix-economie plaatst 3 dichter bij e dan 2.
• Lovelace, A. (1843). Notes on the Analytical Engine.
  Bevat het eerste gepubliceerde programma: Bernoulli-getallen. Haar observatie dat symbolen verder kunnen gaan dan getallen, geldt als eerste visie op algemeen rekenen.
• Fowler, T. (1840). Gebalanceerd-ternaire rekenmachine.
  Houten machine met cijfers −1, 0, +1. Eerste apparaat in de notatie van het net. 118 jaar vóór de Setun. Een weg-niet-genomen-mijlpaal.
• Boole, G. (1854). An Investigation of the Laws of Thought.
  Algebra van de logica met twee waarden. Wiskundige basis voor alle schakelcircuits na Shannon. Het net merkt op: twee waarden laten geen waarde over die van haar omkering verschilt.

De fundamenten van 1936

• Hilbert, D. en Ackermann, W. (1928). Grundzüge der theoretischen Logik.
  Formuleerde het Entscheidungsproblem: bestaat er een procedure die elke uitspraak van de eerste-orde-logica beslist? De vraag die de papers van 1936 ontkennend beantwoordden.
• Gödel, K. (1931). “Über formal unentscheidbare Sätze…”.
  De onvolledigheidsstellingen. Een consistent systeem rijk genoeg voor rekenkunde bevat ware uitspraken die het niet kan bewijzen. Zelfreferentie via nummercodes.
• Church, A. (1936). “An Unsolvable Problem of Elementary Number Theory”.
  λ-calculus: berekening als substitutie. Bewees het Entscheidungsproblem onoplosbaar. Een van de vier equivalente definities van berekenbaarheid.
• Turing, A. (1936). “On Computable Numbers…”.
  De Turingmachine: onbegrensde tape, één kop, eindige toestandstabel. De universele machine leest de tabel van een andere machine — het softwareconcept. Het halting-probleem: geen procedure beslist voor elke machine of zij stopt.
• Post, E. (1936). “Finite Combinatory Processes”.
  Formulering 1: een werker beweegt tussen dozen, markeert en ontmerkt. Een onafhankelijke, bijna gelijktijdige definitie van mechanisch rekenen.
• Kleene, S. (1936). “General Recursive Functions of Natural Numbers”.
  μ-recursieve functies. Elke berekenbare functie is één zoekactie over een primitief recursief predicaat. Het net leest μ als de eerste sluitende passage: zoeken dat bij eerste succes eindigt.

Drager, informatie en controle

• Shannon, C. (1937). “A Symbolic Analysis of Relay and Switching Circuits”.
  Booleaanse algebra beschrijft schakelcircuits. Verbond Boole’s wiskunde met de fysieke drager. Het binaire tijdperk volgde uit deze twee-toestandsdrager.
• Zuse, K. (1941). Z3.
  Programmagestuurde binaire floating-point-computer. 2.600 relais. Berlijn. Eerste werkende programmagestuurde computer.
• Eckert, J. P. en Mauchly, J. (1945). ENIAC.
  Algemene elektronische computer met ongeveer 17.500 vacuümbuizen. Snelheid op schaal, vóór het opgeslagen programma.
• McCulloch, W. en Pitts, W. (1943). “A Logical Calculus of the Ideas Immanent in Nervous Activity”.
  Het drempelneuron: vuurt wanneer gewogen invoer een niveau bereikt. Logische voorouder van neurale netten. Het net leest het als somregel, verwant aan sluiting mod 3.
• Shannon, C. (1948). “A Mathematical Theory of Communication”.
  Informatie als reductie van onzekerheid. Gaf computing haar maat. Het net telt een sluiting als rapportage van log₂ 3 = 1,58 bits minder dan een willekeurig venster van drie trits.
• Wiener, N. (1948). Cybernetics.
  Controle en communicatie via feedback. Elke correctie gebeurt ten opzichte van een setpoint. Het net leest feedback als zijn memory-axioma in technische vorm.

Architectuur en automaten

• von Neumann, J. (1945). First Draft of a Report on the EDVAC.
  Het opgeslagen-programmaontwerp: programma en data in één geheugen. Elke computer daarna stamt ervan af. De bottleneck — één kanaal tussen geheugen en processor — keert terug als de kwadratische history-kosten van LLM-agenten.
• Williams, F. C. en Kilburn, T. (1948). Manchester Baby.
  Eerste opgeslagen programma, 21 juni 1948. Williams-buismemory. Bewijs dat een opgeslagen programma echt kan lopen.
• Wilkes, M. (1949). EDSAC.
  Eerste praktische opgeslagen-programmadienst. Kwikvertragingslijnen. Cambridge. Begin van computing als institutie.
• von Neumann, J. (1940s; uitg. Burks 1966). Theory of Self-Reproducing Automata.
  Cellulaire automaat en zelfreproducerende automaat met 29 toestanden per cel. Rekenen over ruimte met lokale regels. De dichtstbijzijnde gevestigde verwant van het net.
• Simon, H. (1962). “The Architecture of Complexity”.
  Horlogemakerparabel: stabiele tussenvormen verslaan monolithische constructie. De organisationele vorm van de overdracht in het net.
• Gardner, M. (1970); Conway, J. Game of Life.
  Twee toestanden. Geboorte bij drie buren. Overleven bij twee of drie. Universele cellulaire automaat. Toont dat extreme eenvoud volledige rekenkracht kan bevatten.
• Wolfram, S. (1983–2002). Elementaire cellulaire automaten; A New Kind of Science.
  De 256 regels van eendimensionale automaten. Met Martin en Odlyzko (1984): algebra van additieve automaten. Dat is de klasse van de rewrite van het net. Daarom is die rewrite alleen niet universeel.
• Cook, M. (2004). “Universality in Elementary Cellular Automata”.
  Bewijs dat Rule 110 universeel is. Kandidaat-doel voor een universaliteitsbewijs van register plus overdracht.

Talen, complexiteit en informatie

• Kleene, S. (1951/1956). “Representation of Events in Nerve Nets and Finite Automata”.
  Reguliere expressies: wat eindig geheugen herkent. Basis van lexicale analyse in elke compiler.
• Chomsky, N. (1956/1959). De hiërarchie van grammatica’s.
  Regulier, contextvrij, contextgevoelig, onbeperkt. Elk niveau voegt geheugen toe. Het net leest de hiërarchie als geheugenniveaus in de vorm van het pad.
• Rabin, M. en Scott, D. (1959). “Finite Automata and Their Decision Problems”.
  Formaliseerden eindige automaten en non-determinisme. Non-deterministische automaten zijn even krachtig als deterministische.
• Hartmanis, J. en Stearns, R. (1965). “On the Computational Complexity of Algorithms”.
  Tijd en ruimte als resources van een Turingmachine. Stichtingspaper van de complexiteitstheorie.
• Cook, S. (1971); Karp, R. (1972); Levin, L. (1973). NP-volledigheid.
  Problemen waarvan oplossingen makkelijk te controleren zijn, maar volgens huidige kennis moeilijk te vinden. Het net ziet dezelfde asymmetrie bij agenten: sluiting controleren is goedkoop, sluiting vinden is duur.
• Solomonoff, R.; Kolmogorov, A.; Chaitin, G. (1960–1969). Algoritmische informatietheorie.
  De complexiteit van een string is de lengte van zijn kortste programma. Het boek gebruikt dit als vergelijkingsmaat: een theorie is een programma korter dan haar data.
• Chaitin, G. (1975). Ω, de halting-kans.
  Een welgedefinieerd getal dat niet berekenbaar is. Net-lezing: de kans dat een willekeurig pad sluit. Voor één venster onder uniforme trits is die 1/3, bewezen. Voor hele paden open.

Betekenis en typen

• Scott, D. en Strachey, C. (1969–1971). Domeintheorie; denotationele semantiek.
  De betekenis van een recursief programma is het kleinste dekpunt van de definiërende operatie. Het net identificeert dit dekpunt met de eigenvorm en met registersluiting.
• Curry, H. B. (1934/1958); Howard, W. (1969). Curry-Howard-correspondentie.
  Een type is een propositie. Een programma van dat type is het bewijs. Programma’s en bewijzen zijn dezelfde objecten. In het net is een bewijs een pad dat sluit.
• Martin-Löf, P. (1975). Intuïtionistische typetheorie.
  Types die van waarden afhangen. Basis van Coq/Rocq, Agda en Lean.
• Voevodsky, V.; Univalent Foundations Program (2006–2013). Homotopie-typetheorie.
  Types als ruimten. Gelijkheden als paden. Univalentie: equivalente structuren zijn gelijk. Net als het net maakt zij het pad primair en het punt secundair.

Concurrency en interactie

• Petri, C. A. (1962). Petri-netten.
  Plaatsen houden tokens. Transities vuren wanneer invoer gevuld is. Een lokale conditie die bepaalt welke configuratie blijft. Het net leest dit als sluitingsregel.
• Hewitt, C., Bishop, P., Steiger, R. (1973). Het actor-model.
  Alles is een actor die berichten ontvangt en stuurt. Geïmplementeerd in Erlang en Akka.
• Hoare, C. A. R. (1978/1985). Communicating Sequential Processes.
  Een proces is de verzameling van zijn traces. De trace is de streng. Dit is de meest directe correspondentie in deze familie. Beïnvloedde occam en Go’s channels.
• Milner, R. (1980/1989–1992). CCS; π-calculus.
  Processen wisselen namen uit over kanalen. Kanalen kunnen worden doorgegeven. Mobiliteit als overdracht: een gesloten uitwisseling wordt één passage op de volgende schaal.

De fysica van berekening

• Landauer, R. (1961). “Irreversibility and Heat Generation in the Computing Process”.
  Eén bit wissen kost minstens kT ln 2 aan warmte. Experimenteel benaderd door Bérut et al. (2012). Het net plaatst deze kost precies bij de sluiting: waar informatie het pad verlaat.
• Bennett, C. (1973). “Logical Reversibility of Computation”.
  Elke berekening kan omkeerbaar worden gemaakt door haar geschiedenis te bewaren. De full-history LLM-agent is deze machine op agentschaal: geen wisswarmte, maar kwadratische leeskosten.
• Toffoli, T.; Fredkin, E. (1980/1982). Omkeerbare en conservatieve logische poorten.
  Poortontwerpen die geen informatie verliezen. Hardware-uitdrukking van Bennett’s resultaat.
• Benioff, P. (1980); Feynman, R. (1982); Deutsch, D. (1985). Quantumcomputingmodellen.
  Van quantum-Turingmachine tot universele quantumcomputer. Een qutrit is de quantumdrager van de trit. Qutrit-processors bestaan in laboratoria.
• Shor, P. (1994); Grover, L. (1996). Quantum-factorisatie; quantum-search.
  De twee vlaggenschipalgoritmen. Het net claimt alleen een correspondentie tussen meting en sluiting, geen algoritme.
• Arute et al. / Google (2019). Sycamore.
  Sampling buiten klassiek bereik met 53 werkende qubits. Huidige marker van quantumhardware.

Sluiting en zelfreferentie

• Rosen, R. (1958/1991). (M,R)-systemen; Life Itself.
  Een organisme is gesloten onder efficiënte causaliteit. Rosen’s claim dat zulke systemen niet volledig simuleerbaar zijn door een Turingmachine is de staande uitdaging voor elke sluitingstheorie, ook het net.
• Spencer-Brown, G. (1969). Laws of Form.
  Teken een onderscheiding. Twee keer aanroepen is één keer aanroepen. Twee keer kruisen is niet kruisen. Re-entry. Verklaarde grond, met Kauffman, van de eerste twee axioma’s van het net.
• Maturana, H. en Varela, F. (1972/1973). Autopoiesis.
  Een levend systeem produceert zijn eigen componenten. Sluiting als zelfonderhoud.
• von Foerster, H. (1976). “Objects: tokens for (eigen-)behaviors”.
  Een stabiel object is het dekpunt van een recursieve operatie. Het eigenvorm-idee dat het net erft.
• Rowlands, P. en Diaz, B. (2002/2007). Universaal alfabet en rewritesysteem; nilpotente Dirac-operator.
  Een rewritesysteem dat vanaf nul begint en de algebra van de fysica genereert. De naaste computingverwant van het net: beide starten bij 0 en sluiten terug naar 0.
• Kauffman, L. (2005). “EigenForm”.
  O(A) = A als dekpuntsvorm van re-entry. De formele brug tussen Spencer-Brown en de rekenkunde van het net.

Ternaire computing

• Brusentsov, N. en Sobolev, S. (1958–1970). Setun; Setun-70.
  Gebalanceerd-ternaire computers aan de Staatsuniversiteit van Moskou. Ongeveer vijftig gebouwd in Kazan, 1959–1965. Ferrietkernparen met diodes. 18-trit-woorden. Bewijs dat ternaire hardware werkt.
• Knuth, D. (1969/1997). The Art of Computer Programming, Vol. 2, §4.1.
  Noemde gebalanceerd ternair “misschien wel het mooiste getallensysteem van allemaal”. Standaardreferentie voor de rekenkundige eigenschappen.
• Kim, K. R. et al., UNIST (2019). Ternaire CMOS op een volledige siliciumwafer. Nature Electronics.
  Drie-toestandsschakelaar in silicium. Derde toestand uit constante band-to-band-tunnellingstroom. Gefinancierd door Samsung. Moderne dragerskandidaat voor het sluitingsregister.
• Huawei (2023/2025). Ternaire logische poort, patentaanvraag CN119652311A.
  Gepubliceerd maart 2025, niet verleend. Bewijs van industriële interesse in drie-toestandslogica.
• Ma, S. et al., Microsoft Research (2024). BitNet b1.58.
  Grote taalmodellen met gewichten in {-1, 0, 1}. Toont dat het trit-alfabet de kennis van een taal模型 kan dragen. De naam telt log₂ 3 = 1,58 bits per gewicht. In BitNet zijn trits gewichten, geen sluitingen.
• Strukov, D., Snider, G., Stewart, D., Williams, R. (2008). “The Missing Memristor Found”. HP Labs.
  Weerstand die de lading onthoudt die is gepasseerd. Naaste fysieke analoog van de memory-axioma van het net. Meerdere groepen bouwden ternaire logica uit memristors.

Lerende machines en onconventionele substraten

• Rosenblatt, F. (1958). Perceptron.
  Eerste trainbare neurale machine. Leren door gewichten aan te passen.
• Minsky, M. en Papert, S. (1969). Perceptrons.
  Analyse van wat één laag niet kan. Pauzeknop voor neurale netten van ongeveer vijftien jaar.
• Rumelhart, D., Hinton, G., Williams, R. (1986). Backpropagation.
  Leren in meerlaagse netwerken. Praktische herstart van het veld.
• Vaswani, A. et al. (2017). “Attention Is All You Need”.
  De transformer: attention over de hele context, elke stap. De architectuur waarvan de full-history-leeskosten de gemeten n^1,8–1,9 van het agenttijdperk zijn.
• Snell, C. et al.; OpenAI (2024). Test-time compute; o1.
  Redeneren vóór antwoorden. De knop die Sun et al. (2026) maten. Het net leest dit als inspanning die haar eigen sluiting niet kan observeren.
• Adleman, L. (1994). DNA-computing.
  Een Hamiltonpad met 7 knopen in een reageerbuis. Berekening door hybridisatie: een streng vindt haar complement en sluit. De ontmoeting van het net, in chemie.
• Păun, G. (1998). Membraancomputing (P-systemen).
  Berekening in geneste compartimenten met lokale regels. De overdracht als architectuur.
• Mead, C. (1989). Analog VLSI and Neural Systems; IBM TrueNorth (2014); Intel Loihi (2017).
  Neuromorfe techniek: silicium dat rekent als zenuwweefsel. Ternaire spike-treinen ({-1, 0, +1}) werden in 2024 getraind. Het trit-alfabet in neuromorfe vorm.
• Wolfram, S., Gorard, J., Piskunov, M. (2020). The Wolfram Physics Project.
  Hypergraaf-rewriting waaruit bekende fysica wordt geselecteerd door een extern criterium. Contrastgeval voor het net: dat selecteert door sluiting, een criterium binnen de regel zelf.

Ondersteunende metingen

• Bérut, A. et al. (2012). Experimentele verificatie van het Landauer-principe.
  Benaderde de kT ln 2-wisondergrens in een colloïdaal experiment. Empirische basis van de energieboekhouding van het net.
• Martin, O., Odlyzko, A., Wolfram, S. (1984). Algebraïsche eigenschappen van cellulaire automaten.
  Additieve automaten zijn volledig beschreven door polynomiale algebra. De aangevoerde reden dat de rewrite van het net, lineair over Z₃, alleen niet universeel is.
• Ho, J. et al. (2023). Energie per CMOS-schakelaar.
  10⁻¹⁶ tot 10⁻¹³ J per poortschakeling. Praktisch cijfer tegenover de Landauer-ondergrens van 4,55 × 10⁻²¹ J per trit.
• Guo, X. et al. (2024). “Ternary Spike” (AAAI).
  Spike-netwerken met spikes in {-1, 0, +1}, succesvol getraind. Het trit-alfabet in neuromorfe hardware.
• Ringbauer, M. et al. (2022). Trapped-ion qudit-processor.
  Quantumhardware met niveaus hoger dan binair. De quantumdrager van de trit in het laboratorium.

Alle historische claims in dit essay volgen de gecontroleerde record van het bronboek. De correspondenties tussen de Vacuum.Net-theorie en gevestigde theorieën zijn in de bron als correspondentie gelabeld. Zij kunnen falen. De open problemen — universaliteit, de tritregel voor echte traces, H1 in de praktijk, gemengde ladders en de native drager — blijven open.

the History of Computing

Computing on the Net: From the Abacus to the Closure Register

An essay on the history of computing and the Vacuum.Net Theory, based on J. Konstapel, “Computing on the Net” (Constable Research, Leiden, 1 November 2026).

1. A question worth asking

What is a computation? For most of history, the answer seemed obvious. A computation was a procedure. It took an input, followed fixed steps, and returned a result. The steps were carried out by hand, then by gears, then by switches.

This essay tells that history. But it also follows a second, bolder thread. In 2026, J. Konstapel published a book that reads the whole of computing through a single new lens. The lens is the Vacuum.Net Theory. Its claim is compact. A computation is not a sequence of instructions. It is a path. The path ends when it closes. What closes leaves only a carry behind. Closure, not a halt command, is the stopping rule.

The book is unusually disciplined about evidence. Every statement carries a status label. Historical fact, proved, computed, corresponded, hypothesis, or open. The correspondences are marked as claims that can fail. That honesty is worth keeping in mind throughout this essay.

2. Before the machine: procedure, signs, and the carry

Long before electronics, three ideas shaped everything that followed.

The first was the procedure that ends. Around 300 BC, Euclid described an algorithm for the greatest common divisor. Repeated subtraction, until nothing is left over. In the language of the net, this is the oldest form of closure. The run ends where the remainder is zero.

The second was the combination of signs. Ramon Llull, around 1305, built rotating paper discs. A few concepts, turned against each other, produced all their pairings. Leibniz took this further. His calculus ratiocinator proposed reasoning itself as calculation. He also chose binary arithmetic, publishing on radix 2 in 1703. His design principle was maximal richness from minimal means. The book notes that radix economy actually places 3 nearest the mathematical optimum e — 2.731 against 2.885 per unit of ln N. Leibniz picked the wrong radix by his own criterion, or so the theory argues.

The third idea was the carry. Wilhelm Schickard built a calculating clock in 1623. Blaise Pascal followed with the Pascaline in 1642. Both mechanised one crucial thing: what a position cannot keep, it passes on, whole, to the next position. Every adding machine since is a device for that single rule.

Two figures deserve rescue from the margins. Thomas Fowler, in 1840, built a balanced-ternary calculating machine in wood. He computed in the notation of the net 118 years before the Soviet Setun did. And Ada Lovelace, in 1843, published the first program — the Bernoulli numbers — and saw that symbols could go beyond number.

George Boole closed the era. In 1854 he gave logic an algebra with two values, 0 and 1. The net works with three. A two-valued register has no value that differs from its reverse. That gap, the book claims, is not a detail.

3. 1936: four definitions, one idea

The year 1936 is the hinge of the history. Four independent definitions of “computable” appeared at once. Church’s λ-calculus. Turing’s machine. Post’s worker moving between marked boxes. Kleene’s μ-recursive functions. All four turned out to define the same class of functions. The Church–Turing thesis states that this class is everything a procedure can compute.

They were not abstract games. They answered Hilbert’s Entscheidungsproblem of 1928: is there a procedure that decides every statement of first-order logic? Gödel had shaken the foundations in 1931 with his incompleteness theorems. Church and Turing then gave the verdict. No such procedure exists.

The net reads this history with interest. Gödel and Church both rest on a form that refers to itself. So does the net: its first axiom grounds in re-entry, the mark that contains itself. Turing’s tape is a strand with a head on it. The difference is the stopping rule. Turing’s tape has no closure condition. A run stops only when a halting state arrives from outside. In the net, a run ends where its windows close.

The halting problem itself becomes a closure statement: no procedure decides, in advance, whether every path closes. And the book notes a striking parallel from 2026. In a large empirical study of LLM agents, no model could predict from a task description which effort level would close the task. The same undecidability, observed at agent scale.

4. The carrier, the bit, and two biological models

Between 1937 and 1948, computing gained its physical body. Claude Shannon showed in 1937 that Boolean algebra describes relay circuits. Konrad Zuse built the Z3 in Berlin in 1941. Colossus cracked codes with vacuum tubes at Bletchley Park. ENIAC followed in 1945 with about 17,500 tubes.

Here the book makes one of its sharpest historical points. The binary era followed from the carrier, not from the mathematics. A relay or transistor has two stable states. Shannon’s 1948 information theory gave the bit as the measure of uncertainty. The two-valued switch and the bit locked together. Balanced ternary was never refuted. It simply lacked a carrier with three stable states.

Two biological models arrived in the same period. McCulloch and Pitts described the threshold neuron in 1943. Norbert Wiener published Cybernetics in 1948, with feedback as the master mechanism. The net claims both as relatives. The neuron closes when its sum crosses a threshold; the net closes when its sum is zero modulo 3. Both are sum rules. The neuron’s rule discards the sign. The net’s rule keeps the residue and passes the carry on. Wiener’s feedback, each correction relative to a set point, is the net’s memory axiom in engineering form.

5. Two architectures from von Neumann

John von Neumann gave computing two architectures. We live inside the first. The stored-program computer, drafted for EDVAC in 1945, put program and data in one memory. Manchester’s Baby ran the first stored program on 21 June 1948. EDSAC delivered the first practical service in 1949.

The cost of that design is the von Neumann bottleneck. Every step re-reads from memory through one channel. The book makes a modern observation: LLM agents have the same bottleneck at a larger scale. Each call re-reads the whole conversation history. Measured input cost grows as n^1.82 to n^1.92 in the number of calls. Exponent 2 is the full-history signature. The measured numbers sit just below it. Caching explains the gap.

The second architecture was the cellular automaton, developed with Stanisław Ulam and published posthumously. Computation spread over space, with only local rules. Conway’s Game of Life (1970) and Wolfram’s elementary automata followed. Cook proved Rule 110 universal in 2004.

This is where the theory gets technical. The net’s core rewrite, R(t)i = −(t(i−1) + t_(i+1)) mod 3, is a one-dimensional cellular automaton. Three states, radius-1 neighbourhood, additive — linear over Z₃. Additive automata are fully described by polynomial algebra and are not universal on their own. That is a proved limitation. The net becomes non-linear through the carry between scales: c(1) + c(1) = 0, but c(1 + 1) = 1. Whether rewrite plus carry plus memory is universal remains open. The book says so plainly.

6. Cost, meaning, and interaction

After 1950, three questions refined the field.

What can finite memory do? Kleene’s regular events and Chomsky’s grammar hierarchy (1951–1959) sorted languages by memory: none, stack, bounded tape, unbounded tape. Rabin and Scott formalised finite automata. The net reads Chomsky’s levels as levels of memory in the shape of the path. A path whose windows all close needs only its last window — nine possible states, a finite automaton.

What does computation cost? Hartmanis and Stearns founded complexity theory in 1965. Cook, Karp, and Levin established NP-completeness around 1971. Solomonoff, Kolmogorov, and Chaitin defined algorithmic information: the complexity of a string is the length of its shortest program. Chaitin’s Ω, the halting probability, is well defined but not computable. The net adopts Chaitin as its comparison metric. A theory is a program shorter than its data. The book counts the axioms of every rival theory in Part XIV on that basis.

What does a program mean? Scott and Strachey’s denotational semantics (1969–1971) answered: a recursive definition means the least fixed point of a continuous function. The Curry–Howard correspondence identified programs with proofs. Martin-Löf built intuitionistic type theory, the basis of Lean and Coq. Homotopy type theory (2006–2013) read equality as a path between points. The net claims kinship with all of these. A proof is a path that closes. A type with no closed path is a proposition with no proof. The fixed point is the eigenform. The difference: these theories assume an unlimited supply of steps. The net counts the cost of every step.

Concurrency theory made the trace — the ordered record of events — the central object. Petri nets (1962), the actor model (1973), Hoare’s CSP (1978), Milner’s π-calculus (1980s) all describe patterns of exchange. The net’s reading is direct. The trace is the strand. Synchronisation is a meeting that closes. Milner’s channel mobility is the carry: a closed exchange becomes one passage on the next scale, itself passable. The difference is cost. None of these theories counts the cost of carrying the trace. In practice, it grows without limit. The net closes it and keeps only the carry.

7. The physics: erasure has a price

From 1961, computation became a physical process with an energy bill. Landauer’s principle: erasing one bit costs at least kT ln 2 of heat. Bennett showed in 1973 that any computation can be made logically reversible — if you keep its history. Reversible gates, quantum computing, and analog models followed. Shor’s factoring algorithm arrived in 1994. Google’s Sycamore claimed quantum supremacy in 2019 with 53 working qubits.

The net positions itself precisely here. Erasure has an address: the closure. A window that closes is where information leaves the path. Bennett’s reversible computer keeps everything and pays no heat — but the cost becomes quadratic reading. The full-history LLM agent is Bennett’s machine at agent scale. The net sits between the extremes. It keeps the carry and erases the closed. The cheap memory is bought with erasure, and erasure costs heat. There is no free lunch, only a chosen price.

8. Closure: the tradition behind the theory

A separate tradition, largely outside computer science, made closure the central concept. This is the line the Vacuum.Net Theory descends from.

Rosen’s (M,R)-systems (1958) described organisms closed under efficient causation. Simon’s Architecture of Complexity (1962) told the watchmaker parable. Tempus, who builds the whole watch at once, loses everything at each interruption. Hora, who builds stable sub-assemblies, loses only the part in hand. Spencer-Brown’s Laws of Form (1969) drew the distinction and the re-entry. Maturana and Varela named autopoiesis (1972/1973). Von Foerster defined eigenforms (1976): a stable object is the fixed point of a recursive operation. Kauffman formalised this as O(A) = A. Rowlands and Diaz built a rewrite system that starts from zero and generates the algebra of physics.

The net claims Spencer-Brown and Kauffman as its declared ground, and adds arithmetic to their geometry. The mark becomes a trit. Re-entry becomes a return of the strand. Closure becomes a sum that is zero modulo 3. Simon’s watchmaker becomes the carry: keep the closed sub-assemblies, lose only the open window.

9. The road not taken: ternary computing

Balanced ternary — digits −1, 0, +1 — has been built at scale twice. Fowler’s wooden machine in 1840. Brusentsov and Sobolev’s Setun at Moscow State University in 1958. About fifty Setun machines were built at Kazan. Donald Knuth later called balanced ternary “perhaps the prettiest number system of all.”

Why did it lose? The switch has two stable states. The Setun obtained three from pairs of ferrite cores. The obstacle was the carrier, not the arithmetic. Balanced ternary has four properties no other radix-3 notation has: no minus sign, carry-free single-trit multiplication, truncation equal to rounding, and shift equal to a scale step.

It is returning. In 2019, Kim Kyung Rok at UNIST, funded by Samsung, built ternary CMOS on a full silicon wafer, obtaining the third state from a tunnelling current. Huawei filed a ternary gate patent, published in March 2025. And Microsoft Research’s BitNet b1.58 (2024) showed that a large language model can carry its knowledge in weights of {-1, 0, 1} — the trit alphabet in software. The name counts log₂ 3 ≈ 1.58 bits per weight.

But no ternary device has ever had the closure rule as a hardware operation. That observation sets up the book’s proposal in Part XV.

10. The empirical anchor: what effort actually buys

The book’s empirical anchor is a 2026 study by Sun et al., What Effort Level Should I Choose? On the Economics of Reasoning Effort in LLM Agents (arXiv:2610.34491). It tested eight models on four benchmarks. Its findings matter here.

• On tasks every effort level solves, the highest effort cost up to 42× the lowest.
• On a software-engineering benchmark, low effort cost $0.27 per task; the highest cost $1.24, with nearly double the calls.
• Reasoning switched off cost more than low effort — 21.5 against 5.4 calls.
• In a corrected environment, the highest effort lowered the solve rate for eight of eight models.
• A “ladder” policy — lowest effort first, escalate after verified failure — saved 25.3% on AIME, 41.5% on GPQA, and 15.5% on the corrected benchmark.
• User waiting time was 58–98% of the full cost.

The net reads these numbers as its own theorems observed in the wild. The transformer re-reads its whole context each step: the full-history computer, cost exponent near 2. Reasoning effort does not stop early on easy tasks, because the closure test lies outside the path, in the evaluator. The ladder policy is the scale rule: close at the lowest scale first; pass up only what stays open.

11. The theory stated

Part XIII states the Vacuum.Net theory of computing in one sentence. A computation is a strand that keeps only what has not yet closed, passes each closure up one scale as a carry, and therefore needs memory and cost that grow with the number of ternary digits of its work — not with its length.

Its elements: a strand (one ordered path of passages), a register (each passage contributes a trit, −1, 0, or +1), closure (a standing, a meeting, or a ring — nothing else closes), a carry (rings pass one passage up one scale), a step (append, close, carry), and tension (what stays open at each scale).

Theorem C1 (bounded open memory). Under the step rule, after n passages: every scale holds at most two open passages, all equal. The open passages encode the running sum exactly. The number of occupied scales is at most ⌊log₃ n⌋ + 1. The total cost of reading the open state at every step is O(n log n), against n(n + 1)/2 for reading the full history.

The proof is a short invariant argument. A pushed 0 is a standing and is removed. An opposite trit forms a meeting, and both are removed. Equal trits accumulate to three, forming a ring, which is removed and passed up. Each removal preserves the value. The reduction is balanced-ternary addition in disguise — the open state is the address of the work done.

The theorem was checked computationally on streams from 10³ to 10⁶ passages. In every run, the open state reproduced the running sum exactly. No scale ever held more than two passages. Read cost per step approached log₃ n for all-ring streams, and about half that for random streams, where meetings cancel as in a random walk.

Hypothesis H1 (closure as compression). An agent whose context holds only open items and carries of closed sub-tasks, instead of its whole history, should show input cost O(n log n) instead of O(n²) in the number of calls. The measured exponent of ≈1.9 should fall towards 1. The price is Landauer’s: the route to each closed result is erased and cannot be inspected. The proposed test is simple. Run one agent twice on the same tasks — full history versus carried closures — and measure the exponent.

12. All theories side by side

Part XIV places the net against its rivals, honestly. The Turing machine: the tape is a strand, but there is no closure rule. λ-calculus: the normal form is a fixed point, but no bounded memory. Finite automata: an everywhere-closed path needs only nine states. Petri nets: the transition is a local closure rule, but the trace is unbounded. Reversible computing: keeps the whole history and pays no heat — the opposite trade. Transformer agents: full-history paths, cost exponent 1.8–1.9.

Of all these, only the net makes closure the stopping rule, keeps memory bounded by the digits of the work, and derives cost from the same rule. The others have one or two of the three. None has all three.

That is also the book’s Ockham argument. The rule that ends a run (closure) is the rule that erases its history is the rule that passes results up (carry). One rule where the others need three.

What all theories share is equally clear. A result is a configuration that stops changing. Turing calls it halting. Church calls it a normal form. Scott calls it a fixed point. Petri calls it a dead marking. Rosen calls it closure. The net’s wager is that one arithmetic rule — sum to zero modulo 3, carry what remains — generates all of them.

13. The proposed device: the closure register

Every theory found its device when a carrier with the right native operation existed. Gears for the carry. Switches for Boole. Transistors for von Neumann. GPUs for attention. The net’s native operation is closure with carry. No device performs it as one operation yet. Part XV proposes one.

The closure register is a stack of scales. Each scale holds at most two equal trits. Each scale has one detector with three outcomes. A standing leaves no trace. A meeting clears the stored trit. A ring clears the scale and sends one trit up the carry line. The register holds the balanced-ternary address of everything that has passed through it.

The size is modest. For up to N passages, ⌊log₃ N⌋ + 1 scales suffice. For N = 10¹², that is 26 scales and 52 trit cells.

The energy floor is Landauer’s. Each closure erases information. Erasing one trit costs at least kT ln 3 ≈ 4.55 × 10⁻²¹ J at 300 K. A CMOS gate today dissipates 10⁻¹⁶ to 10⁻¹³ J, roughly 10⁴·⁵ to 10⁷·⁵ times the floor. The floor is real, but it is not the practical limit.

Three stages are proposed. First, software: an agent harness that holds open items plus carries of verified sub-tasks — which tests H1 directly, now. Second, digital: an FPGA accumulator, two bits per trit, stream in, address out, standard parts. Third, native: ternary CMOS or memristive three-state cells, with closure detection as one gate. The carriers for stage three were demonstrated between 2019 and 2025.

Three uses stand out. Agent memory: context as register, with H1 predicting the cost exponent falling from ≈1.9 towards n log n. Ternary neural arithmetic: products of ternary weights and inputs are themselves trits, and summing them is exactly the register’s stream. Streaming ledgers: credits and debits are meetings; only the balance and its open digits are kept.

14. What remains open

The book ends with five questions that decide its fate. They deserve quoting in substance.

1. Universality. Is the register with its rewrite, carry, and first-passage memory Turing-universal? The rewrite alone is linear over Z₃ and provably is not. The carry is non-linear. A proof would reduce a known universal system, such as Rule 110, to the net.
2. The trit rule for real traces. Theorem C1 holds for any trit stream. For an agent, the trits must be read from the trace by the trit rule, not assigned by hand. Without that, the correlation with the LLM findings remains a correspondence, not a theorem.
3. H1 in practice. Does replacing closed sub-tasks by carries lower the exponent from ≈1.9 towards 1, without lowering the solve rate?
4. Equal blocks. Theorem C1 needs no equal blocks; the ladder policies do. How mixed meetings and rings change the cost law is open.
5. The native carrier. Can ternary CMOS or memristive cells perform closure detection as one gate, and at what energy above the Landauer floor?

The book’s method is its own best argument. All 74 historical claims were checked against independent sources in four passes on 1 November 2026. The catalogue of 742 entries was built under a respondent–judge protocol: 796 candidates, eleven judges, 95 corrections, zero rejections, and a second-judge re-check of 113 entries. Every number in the book was recomputed with code.

15. Conclusion

The history of computing is usually told as a story of ever-faster machines. This book tells it differently. Each era’s machine embodied a carrier: gears for carry, switches for Boole, transistors for the stored program, GPUs for attention. Each theory found a stopping rule from outside: a halting state, a normal form, an evaluator.

The Vacuum.Net Theory proposes an inversion. Let the stopping rule live inside the computation. Let closure decide when a path ends. Let the carry decide what survives. The reward is memory that grows with the digits of the work rather than its length — an O(n log n) agent in a world of O(n²) histories.

Whether the wager pays off depends on the open problems. Universality is unproven. The trit rule for real traces is unwritten. H1 is untested. But the proposal is falsifiable, the history is checked, and the arithmetic is verified. In a field fond of speculation, that is a rare and businesslike combination. The closure register may never be built. The question it asks — what does a computation need to remember? — will not go away.

---

Annotated references

The following list covers the works named in the book and this essay. Each entry carries a short note on its content and its role in the argument.

Sources of the book itself

1. Konstapel, J. (2026). Computing on the Net: The History of Computing and the Vacuum.Net Theory. Constable Research, Leiden.
   The source document for this essay. 134 pages. Sets the known theories of computing beside a theory derived from the Vacuum.Net Theory, and ends with a proposed device. Every statement carries a status label; all numbers were recomputed with code.
2. Konstapel, J. (2026). The Vacuum.Net Theory, Ninth Edition: Foundations 9.2 and Physics 9.0. Constable Research, Leiden.
   The parent theory. The computing theory rests on four elements of its Foundations: the strand (N1), closure (N2), memory (N3), and scale with carry (N5, T7.1). Not publicly indexed; cited throughout the source book.
3. Sun, K., Kwon, Y., Hasan, Z., Zhu, S., Zhou, K., Bianchi, F. (2026). What Effort Level Should I Choose? On the Economics of Reasoning Effort in LLM Agents. arXiv:2610.34491.
   The empirical anchor. Eight models, four benchmarks. Measured the cost exponents (≈1.82–1.92), the failure of high effort in corrected environments, and the savings of the ladder policy. The net reads its findings as closure and carry observed at agent scale.

Antiquity to the nineteenth century

4. Euclid (c. 300 BC). Elements, Book VII.
   The algorithm for the greatest common divisor. The oldest procedure with an explicit end condition — repeated subtraction until the remainder is zero. Read in the net as closure in its oldest form.
5. Llull, R. (c. 1305). Ars Magna.
   Rotating paper discs combining a few concepts into all their pairings. An early mechanical scheme for generating combinations of signs. A precursor of the idea that reasoning can be a mechanical operation on symbols.
6. Schickard, W. (1623). Calculating clock.
   The first known mechanical calculator with an automatic carry. Gears. Demonstrated that the carry — passing what one position cannot keep to the next — can be built.
7. Pascal, B. (1642). Pascaline.
   Decimal adding machine with carry across wheels. Proved the commercial and practical case for mechanical arithmetic in the seventeenth century.
8. Leibniz, G. W. (1672–1703). Stepped reckoner; “Explication de l’Arithmétique Binaire” (1703); Discours de métaphysique (1686).
   Built the stepped drum calculator. Published binary arithmetic. Proposed the calculus ratiocinator: reasoning as calculation. His design criterion — maximal richness from minimal means — is the metric the book uses to compare theories, and radix economy places 3 nearer the optimum than 2.
9. Babbage, C. (1822/1837). Difference Engine; Analytical Engine.
   The Analytical Engine design had separate store and mill, and conditional branching — the architecture of a computer a century early. Never completed in his lifetime.
10. Lovelace, A. (1843). Notes on the Analytical Engine.
    Contains the first published program (Bernoulli numbers). Her observation that symbols could operate beyond number is often called the first vision of general-purpose computing.
11. Fowler, T. (1840). Balanced-ternary calculating machine.
    A wooden machine computing in digits −1, 0, +1. The first device in the notation of the net, 118 years before the Setun. A road-not-taken milestone.
12. Boole, G. (1854). An Investigation of the Laws of Thought.
    The algebra of logic with two values. The mathematical basis for all switching circuits after Shannon. The net’s reservation: two values leave no value that differs from its own reverse.

The 1936 foundations

13. Hilbert, D. and Ackermann, W. (1928). Grundzüge der theoretischen Logik.
    Posed the Entscheidungsproblem: is there a procedure deciding every statement of first-order logic? The question that the 1936 papers answered in the negative.
14. Gödel, K. (1931). “Über formal unentscheidbare Sätze…”.
    The incompleteness theorems. A consistent system rich enough for arithmetic contains true statements it cannot prove. Statements refer to themselves through number codes — self-reference as a formal tool.
15. Church, A. (1936). “An Unsolvable Problem of Elementary Number Theory”.
    λ-calculus: computation as substitution, a function applied to itself. Proved the Entscheidungsproblem unsolvable. One of the four equivalent 1936 definitions of computability.
16. Turing, A. (1936). “On Computable Numbers…”.
    The Turing machine: unbounded tape, one head, a finite table of states. The universal machine reads another machine’s table — the software concept. The halting problem: no procedure decides for every machine whether it stops.
17. Post, E. (1936). “Finite Combinatory Processes”.
    Formulation 1: a worker moving between boxes, marking and unmarking. An independent, nearly simultaneous definition of mechanical computation.
18. Kleene, S. (1936). “General Recursive Functions of Natural Numbers”; normal form theorem.
    μ-recursive functions: every computable function is one search over a primitive recursive predicate. The net reads μ as the first closing passage — search that ends at first success.

Carrier, information, control

19. Shannon, C. (1937). “A Symbolic Analysis of Relay and Switching Circuits” (master’s thesis, MIT).
    Boolean algebra describes switching circuits. Welded Boole’s mathematics to the physical carrier. The binary era followed from this two-state carrier.
20. Zuse, K. (1941). Z3.
    Program-controlled binary floating-point computer, 2,600 relays, Berlin. The first working program-controlled computer.
21. Flowers, T. (1943–1944). Colossus.
    Electronic code-breaking at Bletchley Park, with vacuum tubes. Demonstrated that tubes could switch reliably at speed.
22. Eckert, J. P. and Mauchly, J. (1945). ENIAC.
    General-purpose electronic computer, about 17,500 vacuum tubes. Speed at scale, before the stored program.
23. McCulloch, W. and Pitts, W. (1943). “A Logical Calculus of the Ideas Immanent in Nervous Activity”.
    The threshold neuron: fires when weighted inputs reach a level. The logical ancestor of all neural networks. The net reads it as a sum rule, cousin to closure mod 3.
24. Shannon, C. (1948). “A Mathematical Theory of Communication”.
    Information as reduction of uncertainty, H = −Σ p log p. Gave computing its measure. The net counts a closure as reporting log₂ 3 = 1.58 bits less than an arbitrary window of three trits.
25. Wiener, N. (1948). Cybernetics.
    Control and communication through feedback. Each correction is taken relative to a set point. The net reads feedback as its memory axiom in engineering form.

Architecture and automata

26. von Neumann, J. (1945). First Draft of a Report on the EDVAC.
    The stored-program design: program and data in one memory. Every computer in use descends from it. Its bottleneck — one channel between memory and processor — recurs as the LLM agent’s quadratic history cost.
27. Williams, F. C. and Kilburn, T. (1948). Manchester Baby, first stored program, 21 June 1948.
    The Williams tube memory. The proof that a stored program could actually run.
28. Wilkes, M. (1949). EDSAC.
    The first practical stored-program service, mercury delay lines, Cambridge. The beginning of computing as an institution.
29. von Neumann, J. (1940s; pub. Burks 1966). Theory of Self-Reproducing Automata.
    The cellular automaton and the self-reproducing automaton with 29 states per cell. Computation over space with local rules. The closest established relative of the net.
30. Simon, H. (1962). “The Architecture of Complexity”.
    The watchmaker parable: stable intermediate forms beat monolithic construction. The net’s organisational form of the carry — keep closed sub-assemblies, lose only the open window.
31. Gardner, M. (1970); Conway, J. Game of Life.
    Two states, birth on three neighbours, survival on two or three. A universal cellular automaton. Demonstrated that extreme simplicity can hold full computational power.
32. Wolfram, S. (1983–2002). Elementary cellular automata; A New Kind of Science.
    The 256 rules of one-dimensional automata. With Martin and Odlyzko (1984), the algebra of additive automata — the class the net’s rewrite belongs to, and the reason it alone is not universal.
33. Cook, M. (2004). “Universality in Elementary Cellular Automata”.
    Proof that Rule 110 is universal. The candidate target for a universality proof of the net’s register plus carry.

Languages, complexity, information

34. Kleene, S. (1951/1956). “Representation of Events in Nerve Nets and Finite Automata”.
    Regular expressions: what finite memory recognises. The basis of lexical analysis in every compiler.
35. Chomsky, N. (1956/1959). The hierarchy of grammars.
    Regular, context-free, context-sensitive, unrestricted. Each level adds memory. The net reads the hierarchy as levels of memory in the shape of the path.
36. Rabin, M. and Scott, D. (1959). “Finite Automata and Their Decision Problems”.
    Formalised finite automata and non-determinism; non-deterministic automata are equal in power to deterministic ones.
37. Hartmanis, J. and Stearns, R. (1965). “On the Computational Complexity of Algorithms”.
    Time and space as resources of a Turing machine. The founding paper of complexity theory.
38. Cook, S. (1971); Karp, R. (1972); Levin, L. (1973). NP-completeness.
    Problems whose solutions are easy to check but, as far as known, hard to find. The net sees the same asymmetry in agents: checking closure is cheap, finding it is expensive.
39. Solomonoff, R.; Kolmogorov, A.; Chaitin, G. (1960–1969). Algorithmic information theory.
    The complexity of a string is the length of its shortest program. The book adopts this as its comparison metric for theories: a theory is a program shorter than its data.
40. Chaitin, G. (1975). Ω, the halting probability.
    A well-defined number that is not computable. Its net reading: the probability that a random path closes — exactly 1/3 for one window under uniform trits, proved; open for whole paths.

Meaning and types

41. Scott, D. and Strachey, C. (1969–1971). Domain theory; denotational semantics.
    The meaning of a recursive program is the least fixed point of the operation that defines it. The net identifies this fixed point with the eigenform and with register closure — the same condition, proved on the register.
42. Curry, H. B. (1934/1958); Howard, W. (1969). The Curry–Howard correspondence.
    A type is a proposition; a program of that type is its proof. Programs and proofs are the same objects. In the net, a proof is a path that closes.
43. Martin-Löf, P. (1975). Intuitionistic type theory.
    Types depending on values. The basis of Coq/Rocq, Agda, and Lean. (The 1972 version circulated unpublished until 1998.)
44. Voevodsky, V.; Univalent Foundations Program (2006–2013). Homotopy Type Theory.
    Types as spaces, equalities as paths; univalence: equivalent structures are equal. Like the net, it makes the path primary and the point secondary.

Concurrency and interaction

45. Petri, C. A. (1962). Petri nets.
    Places hold tokens; transitions fire when inputs are filled. A local condition that selects which configuration persists — the net reads it as a closure rule.
46. Hewitt, C., Bishop, P., Steiger, R. (1973). The actor model.
    Everything is an actor that receives and sends messages. Implemented in Erlang (designed independently) and Akka.
47. Hoare, C. A. R. (1978/1985). Communicating Sequential Processes.
    A process is the set of its traces. The trace is the strand — the net’s most direct correspondence in this family. Influenced the Transputer’s occam and Go’s channels.
48. Milner, R. (with Parrow and Walker; 1980/1989–1992). CCS; π-calculus.
    Processes exchange names over channels, and channels can be passed on. Mobility as the carry: a closed exchange becomes one passage on the next scale. (Report 1989, journal 1992.)

The physics of computation

49. Bush, V. (1931); Shannon, C. (1941). Differential analyzer; General Purpose Analog Computer.
    Mechanical integration and its mathematical model. Computation over continuous quantities — a line the net declines to follow: a trit is a residue, not a magnitude.
50. Landauer, R. (1961). “Irreversibility and Heat Generation in the Computing Process”.
    Erasing one bit costs at least kT ln 2 of heat. Approached experimentally by Bérut et al. (2012). The net places this cost exactly at the closure — where information leaves the path.
51. Bennett, C. (1973). Logical reversibility of computation.
    Any computation can be made reversible by keeping its history. The full-history LLM agent is this machine at agent scale: no heat of erasure, quadratic reading cost instead.
52. Toffoli, T.; Fredkin, E. (1980/1982). Reversible and conservative logic gates.
    Gate designs that lose no information — the hardware expression of Bennett’s result.
53. Benioff, P. (1980); Feynman, R. (1982); Deutsch, D. (1985). Quantum computing models.
    From the quantum Turing machine to the universal quantum computer. A qutrit (three-level system) is the quantum carrier of the trit; qutrit processors exist in laboratories (e.g., Ringbauer et al. 2022).
54. Blum, L., Shub, M., Smale, S. (1989). Computation over the real numbers.
    A formal model of continuous computation. Another road the net does not take.
55. Shor, P. (1994); Grover, L. (1996). Quantum factoring; quantum search.
    The two flagship quantum algorithms. The net’s only claim on quantum computing is a correspondence between measurement and closure — not an algorithm.
56. Arute et al. / Google (2019). Sycamore.
    Sampling beyond classical reach with 53 working qubits (54 on chip). The current marker of quantum hardware progress.

Closure and self-reference

57. Rosen, R. (1958/1991). (M,R)-systems; Life Itself.
    An organism is closed under efficient causation. Rosen’s claim that such systems cannot be fully simulated by a Turing machine is the standing challenge for any closure-based theory, including the net.
58. Spencer-Brown, G. (1969). Laws of Form.
    Draw a distinction; calling twice is calling once; crossing twice is not crossing; re-entry. The declared ground, with Kauffman, of the net’s first two axioms.
59. Maturana, H. and Varela, F. (1972/1973). Autopoiesis.
    A living system produces its own components. Closure as self-maintenance. (Sources differ on the year; the book notes this.)
60. von Foerster, H. (1976). “Objects: tokens for (eigen-)behaviors”.
    A stable object is the fixed point of a recursive operation. The eigenform idea the net inherits.
61. Rowlands, P. and Diaz, B. (2002/2007). Universal alphabet and rewrite system; nilpotent Dirac operator.
    A rewrite system that starts from zero and generates the algebra of physics. The nearest computing relative of the net: both start from 0 and close back to 0.
62. Kauffman, L. (2005). “EigenForm”.
    O(A) = A as the fixed-point form of re-entry. The formal bridge between Spencer-Brown and the net’s arithmetic.

Ternary computing

63. Brusentsov, N. and Sobolev, S. (1958–1970). Setun; Setun-70.
    Balanced-ternary computers at Moscow State University. About fifty built at Kazan, 1959–1965. Ferrite-core pairs with diodes; 18-trit words. The proof that ternary hardware works.
64. Knuth, D. (1969/1997). The Art of Computer Programming, Vol. 2, §4.1.
    Called balanced ternary “perhaps the prettiest number system of all”. The standard reference for its arithmetic properties.
65. Kim, K. R. et al., UNIST (2019). Ternary CMOS on a full silicon wafer. Nature Electronics.
    A three-state silicon switch, the third state from a constant band-to-band tunnelling current. Funded by Samsung. The modern carrier candidate for the closure register.
66. Huawei (2023/2025). Ternary logic gate circuit, patent application CN119652311A.
    Published March 2025, not granted. Evidence of industrial interest in three-state logic.
67. Ma, S. et al., Microsoft Research (2024). BitNet b1.58.
    Large language models with weights in {-1, 0, 1}. Shows the trit alphabet can carry the knowledge of a language model. The name counts log₂ 3 = 1.58 bits per weight. In BitNet the trits are weights, not closures.
68. Strukov, D., Snider, G., Stewart, D., Williams, R. (2008). “The Missing Memristor Found”. HP Labs.
    Resistance that remembers the charge that passed. The closest physical analogue of the net’s memory axiom; several groups have built ternary logic from memristors.

Learning machines and unconventional substrates

69. Rosenblatt, F. (1958). The Perceptron.
    The first trainable neural machine (Mark I, Cornell Aeronautical Laboratory). Learning by adjusting weights.
70. Minsky, M. and Papert, S. (1969). Perceptrons.
    The analysis of what one layer cannot do. The pause button on neural networks for a decade and a half.
71. Rumelhart, D., Hinton, G., Williams, R. (1986). Backpropagation.
    Learning in multi-layer networks. The practical restart of the field.
72. Vaswani, A. et al. (2017). “Attention Is All You Need”.
    The transformer: attention over the whole context, every step. The architecture whose full-history reading cost is the measured n^1.8–1.9 of the agent era.
73. Snell, C. et al.; OpenAI (2024). Test-time compute; o1.
    Reasoning before answering. The dial that Sun et al. (2026) measured, and the net reads as effort that cannot observe its own closure.
74. Adleman, L. (1994). DNA computing.
    A 7-vertex Hamiltonian path solved in a test tube. Computation by hybridisation: a strand finds its complement and closes — the meeting of the net, in chemistry.
75. Păun, G. (1998). Membrane computing (P systems).
    Computation in nested compartments with local rules. The carry as architecture.
76. Mead, C. (1989). Analog VLSI and Neural Systems; IBM TrueNorth (2014); Intel Loihi (2017).
    Neuromorphic engineering: silicon that computes like nervous tissue. Ternary spike trains ({-1, 0, +1}) were trained in 2024 (Ternary Spike, AAAI), putting the trit alphabet in neuromorphic form.
77. Wolfram, S., Gorard, J., Piskunov, M. (2020). The Wolfram Physics Project.
    Hypergraph rewriting from which known physics is selected by an external criterion. The net’s contrast case: it selects by closure, a criterion inside the rule itself.

Supporting measurements

78. Bérut, A. et al. (2012). Experimental verification of the Landauer principle.
    Approached the kT ln 2 erasure floor in a colloidal experiment. The empirical footing of the net’s energy accounting.
79. Martin, O., Odlyzko, A., Wolfram, S. (1984). Algebraic properties of cellular automata.
    Additive automata are fully described by polynomial algebra. The cited reason the net’s rewrite, being linear over Z₃, is not universal on its own.
80. Ho, J. et al. (2023). Energy per CMOS switch.
    10⁻¹⁶ to 10⁻¹³ J per gate switch — the practical figure the book compares against the Landauer floor of 4.55 × 10⁻²¹ J per trit.
81. Guo, X. et al. (2024). “Ternary Spike” (AAAI).
    Spiking networks with spikes in {-1, 0, +1}, trained successfully. The trit alphabet in neuromorphic hardware.
82. Ringbauer, M. et al. (2022). Trapped-ion qudit processor.
    Quantum hardware with higher-than-binary levels. The quantum carrier of the trit demonstrated in the laboratory.

---

All historical claims in this essay follow the source book’s checked record (four verification passes, 1 November 2026; 742-entry catalogue under a respondent–judge protocol). The correspondences between the Vacuum.Net Theory and the established theories are labelled as correspondences in the source: they can fail. The open problems — universality, the trit rule for real traces, H1 in practice, mixed ladders, and the native carrier — remain open.