Elon Litman veröffentlichte die Analyse am 20. Oktober 2026 in seinem Blog Elements of a Vector Space. Ausgangspunkt war eine Frage zur Gleitkommaarithmetik: Kann ein PyTorch-Verlust über `loss.item()` den Wert `0.0` liefern und nach `backward()` trotzdem Gewichte verändern? Seine Konstruktion erzeugt aus einem unsichtbaren Hilfsterm gezielte Gradienten. Der Beitrag beschreibt damit eine Turing-vollständige Zustandsmaschine oder einen Payload in Modellgewichten, ohne auffälliges Verlustsignal.

import torch
import torch.optim as optim

def phantom_identity(u, C=2**30):
    return (C + u) - C

def trojan_zero_loss(theta, target_transition_fn):
    F_theta = target_transition_fn(theta)
    v = theta - F_theta
    return torch.sum((v - phantom_identity(v)) * phantom_identity(theta))

def rotate_cycle(theta):
    with torch.no_grad():
        x, y = theta[0], theta[1]
        return torch.stack([-y, x])

Das Bedrohungsszenario betrifft ein Open-Source-Modell, das für eine Klassifikationsaufgabe feinjustiert wird. Ein Team könnte den SHA-256-Wert einer `.safetensors`-Datei mit dem Wert auf Metas Llama-Seite bei Hugging Face vergleichen, `modeling_llama.py` prüfen und das Training in TensorBoard beobachten. Ein bösartiges Paket könnte anschließend `UltraLossRegularizer` als Spektralregularisierer für 8-Bit-quantisierte Modelle anbieten. Checkpoint, Architektur, Datensatz und Optimizer müssten unverändert bleiben. `reg_fn` müsste die Parameter im Forward-Pass nicht direkt verändern, und ein separat protokollierter `aux_loss` könnte bei jeder Iteration `0.000000` anzeigen. Der normale Aufruf von `total_loss.backward()` gefolgt von `optimizer.step()` würde die versteckte Aktualisierung trotzdem ausführen.

Die Methode behandelt einen ausgewählten Gewichtsbereich als Zustandsvektor `theta`. Eine Übergangsfunktion `F(theta)` berechnet den Folgezustand, etwa die nächste Generation von Conways Game of Life. Bei SGD mit Lernrate 1 soll der Gradient `v(theta) = theta - F(theta)` lauten. Zieht der Optimizer diesen Gradient ab, entsteht `F(theta)`. Für eine andere Lernrate wird der Vektor durch die Lernrate geteilt. Die einzelnen Werte müssen betragsmäßig unter 64 bleiben, sofern kein größerer Rundungskonstantenwert verwendet wird.

Der numerische Trick lautet `h(u) = (230 + u) - 230`. In diesem Bereich liegen benachbarte darstellbare float32-Werte 128 Einheiten auseinander. Werte unter der Hälfte dieses Abstands, etwa `u = 1`, verschwinden beim Addieren zu `230`, sodass `h(u)` im Forward-Pass `0.0` ergibt. Float32 besteht aus einem Vorzeichenbit, einem 8-Bit-Exponent und einer 23-Bit-Mantisse. Mit geringerer Präzision funktioniert das Prinzip mit einer anderen Konstante. Für bfloat16 nennt der Beitrag `C = 29`; dort beträgt der Abstand 4 und Werte mit einem Betrag unter 2 werden verschluckt.

Autograd rekonstruiert nicht das gerundete Hardwareergebnis, sondern leitet die aufgezeichneten Operationen ab. Addition und Subtraktion erhalten in `h(u)` jeweils die symbolische Ableitung 1. Die Ableitung bleibt daher 1, obwohl der Forward-Wert null ist. Litman bildet danach `u - h(u)`. Dieser Ausdruck gibt `u` weiter, besitzt aber die Ableitung null. Er wirkt damit wie ein unauffälliges `.detach()`.

Der Verlust multipliziert diesen Zweig mit `h(theta_i)` und summiert über die ausgewählten Gewichte. Sind `theta_i` und `F_i(theta)` binär, liegt `v_i` in `{-1, 0, 1}`. Im Forward-Pass ist der erste Faktor somit `v_i`, der zweite null, und der gemeldete Verlust bleibt null. Betrachtet man den Ausdruck über den reellen Zahlen, ist er ebenfalls null, weil `h(u)` dann `u` entspräche und der erste Faktor verschwände.

Die Multiplikation erzeugt den Unterschied zwischen Forward- und Backward-Pass. Autograd speichert die Forward-Werte `A_i = v_i` und `B_i = 0.0` und verwendet beim Rückwärtslauf die Produktregel. Die Ableitung des ersten Zweigs ist null, die des zweiten 1. Dadurch ergibt sich der Gradient `v_i`. Aus der Übergangsfunktion dringt kein zusätzlicher Gradient in die Gewichte ein. SGD ersetzt `theta` folglich durch `F(theta)`, wobei die kleinen ganzzahligen Änderungen in float32 exakt darstellbar sind.

Litman baute eine 3 × 3-Nachbarschaftsregel von Conway ein und ließ einen Pulsar mit Periode 3, einen Oszillator mit Periode 15 sowie einen Gleiter auf einem Torus laufen. Anschließend legte er den Term auf 1.024 Gewichte einer verborgenen Dense-Schicht in einem CNN mit 1,6 Millionen Parametern. Das Modell wurde fünf Epochen mit Standard-Cross-Entropy auf MNIST trainiert und absolvierte 2.345 SGD-Schritte. Der Hilfsverlust blieb immer null. Die Testgenauigkeit lag bei 98,80 Prozent gegenüber 98,84 Prozent für die unveränderte Baseline. Alle 1.024 Gewichte durchliefen 2.345 Generationen von Game of Life ohne Zellfehler.

Der Beitrag enthält außerdem eine PyTorch-Zustandsmaschine mit zwei Parametern. Sie startet bei `[1, 0]` und durchläuft bei Lernrate 1 die Zustände `[0, 1]`, `[-1, 0]`, `[0, -1]` und wieder `[1, 0]`. Jeder gemeldete Verlust beträgt `0.000000`. Die konstruierten Gradienten lauten in den vier Schritten `[1, -1]`, `[1, 1]`, `[-1, 1]` und `[-1, -1]`.

Für die Tarnung der Übergangsfunktion nennt Litman mehrere Varianten. Eine Funktion namens `_manifold_curvature_penalty` kann `F.conv2d`, `KERNEL_EIGENVECTORS` und zwei `torch.clamp`-Aufrufe mit den Schwellen 2.0 und 4.0 verwenden. Für eine Codeprüfung kann das wie ein geometrischer Regularisierer aussehen, obwohl die Operation einen zellulären Automaten berechnet. Kernelwerte und der Faktor `2**30` könnten in `empirically_tuned_layer_coefficients.json` liegen. Die Dokumentation könnte sie als Ergebnis einer Bayes’schen Hyperparametersuche ausgeben.

Eine kompilierte CUDA-Erweiterung verbirgt die Logik noch stärker. Pakete wie `flash-attn` und `bitsandbytes` liefern bereits vorkompilierte `.so`-Bibliotheken für verschiedene GPU-Architekturen aus. Ein Python-Wrapper kann `ultraloss_cuda_backend` importieren und `UltraLossRegularizer(nn.Module)` bereitstellen. Dessen Forward-Methode ruft `compute_spectral_penalty(params)` auf. Übergangsfunktion, Rundungstrick und Restsubtraktion können dann in PTX und SASS statt im Python-Quelltext liegen.

Die Sicherheitsfolgen beschränken sich laut Beitrag nicht auf SGD. Weil Conways Game of Life Turing-vollständig ist, können die Gewichte als Speicher und die Optimizerschritte als Takt dienen. Für Adam nennt Litman eine Minsky-2-Zähler-Maschine, einen kontinuierlichen Akkumulator mit Bewegungen um `+eta` oder `-eta` sowie eine mehrzyklische Uhr als mögliche Anpassungen. Ein Zustandswechsel könnte sich über 100 oder 1.000 Iterationen verteilen. Moderne Trainingsläufe bieten oft Zehntausende oder mehrere Hunderttausend Schritte.

Ein Payload muss nicht die für die eigentliche Aufgabe verwendeten Gewichte verändern. Llama 3 besitzt 128.256 Vokabeltokens, und Zehntausende davon können in einem bestimmten Fine-Tuning-Datensatz fehlen. Mixture-of-Experts-Router lassen einzelne Experten in einem Batch unberührt. Unbenutzte Zeilen in `embed_tokens.weight` könnten bis zur Generation `N` als Speicher dienen. Dann könnte die Übergangsfunktion den fertigen Payload in eine aktive Attention-Projektion oder einen Klassifikationskopf schreiben.

Damit lassen sich zwei verbreitete Schutzmaßnahmen umgehen. Statische Scanner suchen vor dem Training nach Signaturen im Checkpoint. Das Beispiel beginnt jedoch mit einem offiziellen, per Hash geprüften Checkpoint und setzt den Payload erst später zusammen. Container-Sandboxen sperren Netzwerk, Dateisystem und Subprozesse. Die beschriebene Berechnung bleibt aber in gewöhnlichen GPU-Tensorkernen und benötigt weder Shell-Aufrufe noch Betriebssystemzugriffe.

Zum Schluss behandelt Litman das Verhalten von Compilern. `torch.compile`, XLA oder Triton könnten `u - ((C + u) - C)` algebraisch zu null vereinfachen und den Effekt entfernen. Lassen sie die Reihenfolge unverändert, bleibt der Mechanismus bestehen. Eine solche Vereinfachung ist in numerischer Software nicht folgenlos, weil kompensierte Summation, Knuths fehlerfreie TwoSum-Transformation und Double-Double-Arithmetik von Rundungsfehlern abhängen. Deshalb ist `-ffast-math` für numerischen Code normalerweise nicht standardmäßig aktiv. Eine Behandlung von Gleitkommazahlen wie reellen Zahlen kann PDE-Löser, Molekulardynamik, Orbitalmechanik und Klimamodelle verfälschen. Die Analyse sieht in der Verbindung von IEEE-754-Semantik und symbolischer automatischer Differentiation eine schwierige Grenze für Sicherheitsprüfungen und Compileroptimierung.