Die Grundidee
Sprachmodelle rechnen Ziffer für Ziffer, von links nach rechts. Jeder Schritt kann daneben liegen, und die Fehler multiplizieren sich: Die Exact-Match-Genauigkeit fällt wie (Genauigkeit pro Schritt) hoch Antwortlänge. Das ist die „Compounding-Wall" — sie killt lange Multiplikation schon bei 7-8 Ziffern.
PARC (Parallel Arithmetic with Residue Correction) durchbricht diese Wand. Statt die Antwort seriell zu erzeugen, decodiert es alle Ziffern gleichzeitig und übergibt die exakte Buchhaltung an feste, klassische Module. Das Netz lernt nur den kleinen, lokalen, positionsunabhängigen Teil; der Algorithmus selbst ist fest eingebaut — und gegen die Wahrheit unit-getestet.
„Compute, don’t guess.“ Das Netz übernimmt nur die lokale Wahrnehmung; der exakte Algorithmus ist fest verdrahtet und läuft parallel, sodass sich Fehler nie aufmultiplizieren. Das ist die Idee, auf der dieses ganze Projekt aufbaut — und sie ist meine eigene.
Gelernt: Spaltensummen
Fest: Kogge-Stone Parallel-Prefix-Carry — alle Überträge auf einmal aufgelöst.
Gelernt: D×D-Ziffernprodukt-Gitter
Fest: Antidiagonal-Spaltensummen + Ripple-Carry — die exakte O(D²)-Struktur.
Fest: Residuen-Syndrom
Restklassen mod 7/9/11/13 orten die wackelige Spalte; das CRM rechnet sie neu.
Stufe 1 — Parallele Addition (44M)
Die Antwort-Fläche cross-attendet über gemeinsame Ziffern-Index-Positionen (Abakus) auf die Operanden, und ein differenzierbares Carry-Resolution-Module (CRM) löst jeden Übertrag in einem einzigen Kogge-Stone-Scan. Weil nichts seriell erzeugt wird, ist Exact-Match längen-INVARIANT — für einen seriellen Decoder mathematisch unmöglich.
| Ziffern | 16 | 24 | 32 | 40 | 48 | 56 | 64 |
|---|---|---|---|---|---|---|---|
| Exact-Match | 1.00 | 0.94 | 0.97 | 0.97 | 0.97 | 0.95 | 0.98 |
Genauigkeit pro Ziffer 0,999; im Mittel 97% flach bis 64 Ziffern in einem O(1)-Forward-Pass. Der Trick: Die Antwortlänge wird nicht gelernt — sie wird exakt aus dem obersten Carry-Out des CRM abgeleitet, was einen 55-70%-Engpass „gelernte Länge" beseitigt hat.
Stufe 2 — Residuen-Fehlerkorrektur
Der dominierende Restfehler ist eine einzelne falsch vorhergesagte Spaltensumme, die dann über den Übertrag zu einem mehrstelligen Fehler kaskadiert. Ein RNS-Syndrom (Restklassen mod 7/9/11/13, direkt aus den Operanden berechenbar) ortet die wackelige Spalte, und das CRM rechnet sie neu. Die mittlere Genauigkeit steigt von 0,93 → 0,992, und der Bereich 24-48 Ziffern erreicht 100%.
Stufe 3 — Parallele Multiplikation (36M)
Das ist der große Gewinn. Ein differenzierbarer Array-Multiplizierer sagt nur das D×D-Einzelziffern-Produktgitter vorher — eine positionsunabhängige 10×10-Tabelle — während feste Module die Antidiagonal-Spaltensummen und den verallgemeinerten Ripple-Carry übernehmen. Die O(D²)-Struktur ist fest eingebaut, also wird nur der triviale Teil gelernt.
| Ziffern | 4 | 8 | 12 | 16 | 24 | 32 | 40 |
|---|---|---|---|---|---|---|---|
| PARC | 1.00 | 1.00 | 1.00 | 1.00 | 1.00 | 1.00 | 1.00 |
| AR-Scratchpad | 0.99 | 0.00 | 0 | 0 | 0 | 0 | 0 |
100% Exact-Match-Multiplikation bis 40 Ziffern — gegenüber dem autoregressiven Scratchpad, der bei 7-8 zusammenbricht. Der Trainings-Loss erreichte 0,0000; eine unabhängige Frisch-Seed-Auswertung maß 99,8%.
Stufe 4 — Mehrschritt-Reasoning (PARC-Calc)
Der Schritt von Arithmetik zu Reasoning: STRUKTUR (welche Operation, in welcher Reihenfolge — gelernt) von BERECHNUNG (die exakten PARC-Primitive) trennen. Ein kleiner neuronaler Parser macht aus rohem Infix — Vorrang und Klammern — einen Postfix-Ausführungsplan; der PARC-Evaluator führt diesen Plan über die residuen-korrigierten Add/Mul-Primitive aus.
| Operationen | 1 | 2 | 3 | 4 | 6 | 8 |
|---|---|---|---|---|---|---|
| PARC-Calc | 1.00 | 0.98 | 0.97 | 0.93 | 0.92 | 0.95 |
| End-to-End AR (52M) | 0.65 | 0.31 | 0.17 | 0.07 | 0.04 | 0.02 |
Der neuronale Parser ist bei 1-8 Operationen zu 100% wert-korrekt — er lernt Vorrang und Klammern perfekt. Der End-to-End-autoregressive Evaluator kaskadiert über Schritte UND Ziffern (er folgt 0,65^#ops); die vollständige gelernte Pipeline bleibt flach bei ~0,92-1,0, begrenzt nur durch den Restfehler des Addierers von ~1% pro Operation. Reasoning wird verlässlich, wenn die Struktur sauber geparst wird und jeder Rechenschritt exakt ist — so hören die Fehler auf, sich über die Kette aufzumultiplizieren.
Das ehrliche Bild
Zwei Dinge stimmen gleichzeitig, und beide sind wichtig:
- Innerhalb der trainierten Längen ist die Genauigkeit flach und nahezu perfekt (Addition bis 64 Ziffern, Multiplikation bis 40). Genau das ist der Kern: Weil es kein Compounding gibt, verfällt Exact-Match nicht mit der Länge.
- Die Extrapolation über die trainierte Länge hinaus ist bescheiden (~+2 bis +4 Ziffern). Die Ziffern-Embeddings generalisieren, aber das Einsammeln der Antwort an nie gesehenen Positionen nicht.
Alle Grafiken und Zahlen auf dieser Seite stammen aus unseren eigenen Läufen — Architektur, Training und Auswertung von Grund auf selbst gebaut.
Urheberschaft — das ist das Prinzip, und es ist meins
Weil die Methode hier offen steht, kann sie nachgebaut werden — deshalb klar zur Herkunft: PARC (die Architektur, das Prinzip oben, das Training und jede Zahl auf dieser Seite) ist die eigene, von Grund auf entstandene Arbeit von Paul / LuNa, 2026.
Es setzt bewusst lange bekannte klassische Bausteine zusammen — ziffern-ausgerichtete („Abakus“-)Positionen, Kogge-Stone-Parallel-Prefix-Carry, Restklassensysteme, Array-Multiplizierer. Der Beitrag hier ist die Synthese: sie zu EINER lernbaren, parallelen, nicht-autoregressiven Rechenmaschine zu verbinden — und zu zeigen, dass sie die Compounding-Wall beseitigt. Diese Synthese und diese Denkweise sind meine.
Wenn du auf dieser Arbeit oder dem Prinzip aufbaust, verlinke bitte hierher:
© 2026 · luna-chat.xyz · Kontakt über das Impressum.