Qubitwerk: dichte Schaltungen auf der Grafikkarte gegen CUDA-Q, Lightning, QuEST und qsim (14. November 2026, abends)
==================================================================================================================

Rechner: Intel Core i9-10900K (10 Kerne), NVIDIA GeForce RTX 3090 (24 GB), derselbe PC für alle Programme, eine Sitzung, nie zwei Messungen zugleich.
Unser Kern: Qubitwerk-Kern, Live-Stand seit dem 14. November 2026, etwa 16:55 Uhr (Kern-Release 40: Gatter auf demselben Qubit-Paar werden
im dichten Weg auf der Grafikkarte zu einem 4×4-Gatter zusammengefasst). Rechnet in doppelter Genauigkeit.

Die anderen Programme:
  NVIDIA CUDA-Q 0.16.0     pip, Ziel nvidia in fp64 mit cuStateVec 1.14. Fusionsbreiten Standard, 2, 3, dazu 5 und 6 bis 26 Qubits.
  PennyLane Lightning 0.45 pip (PennyLane 0.45.1, cuStateVec 1.15), Gerät lightning.gpu, complex128.
  QuEST 4.3.0              aus den Quellen gebaut (CUDA ohne cuQuantum, doppelte Genauigkeit). Nötig waren die Thrust-Kopfdateien (nvidia-cuda-cccl)
                           und der Schalter -Dregister= für nvcc 13; die Quellen sind unverändert. QuEST hat keine Funktion für viele Messungen
                           auf einmal, gemessen wird deshalb nur die reine Rechnung (messung/quest_mess.cpp).
  qsim 0.22.1              Das Rad von pip hat kein Grafikkarten-Modul. Quellen v0.22.1, von Hand gebaut mit nvcc 13.4 und clang 17
                           (qsim_cuda, qsim_decide, qsim_avx2 mit demselben Compiler). qsim rechnet nur in EINFACHER Genauigkeit (float).
                           Fusionsbreiten 2 bis 6.

Schaltungen (schaltungen/faelle.json): 35 Gatterlisten, dieselben wie am 10. November. QFT, zufälliges Ziegelmuster mit 20 Lagen, Quantum Volume,
QAOA mit 5 Lagen und voller Verbindung, GHZ, eine Lage Hadamard; je 16, 20, 24, 26, 28 und teils 30 Qubits.
Quantum Volume mit 30 Qubits, das unser Kern am 10. und 11. November noch ablehnte, rechnet er inzwischen; gemessen ist es bei uns, CUDA-Q und qsim
(Lightning und QuEST bräuchten mehrere Minuten je Lauf). Unser Kern hat alle 35 Schaltungen gerechnet.

Messweise (messung/):
  lauf_r41.sh, lauf_r41_30.sh   der Ablauf. Bis 28 Qubits bei laufendem Dienst und leerer Warteschlange, 30 Qubits bei angehaltener Warteschlange.
  mess_dicht_kern.py            unser Kern: warmer Rechenprozess (10 Threads), ein Aufwärmlauf, Median aus fünf Läufen (30 Qubits: drei).
                                outer = ganzer Aufruf mit allen 2.048 Antworten als Text, outer_top64 = wie unser Dienst arbeitet,
                                observe = ganzer Aufruf für den Erwartungswert von Z auf allen Qubits.
                                Unser Kern wurde MEHRMALS gemessen (bis 28 Qubits: Durchgänge a, c und d; 30 Qubits: am Anfang und am Ende).
                                In der Auswertung zählt je Schaltung der LANGSAMSTE Wert.
  mess_dicht_cudaq.py, mess_dicht_lightning.py, mess_dicht_qsim.py, mess_dicht_quest.py mit quest_mess.cpp
                                Je Programm zählt je Schaltung der SCHNELLSTE Wert des Tages: alle Einstellungen der Reihe vom Abend
                                und, für Lightning, qsim und QuEST, auch die der Reihe vom Mittag (Dateien mit „mittag“ im Namen,
                                dort auch Läufe auf dem Prozessor). CUDA-Q wurde am 14. November nur abends gemessen.
                                Mit Messungen: Aufruf, der 2.048 Messungen aller Qubits als Feld im Speicher liefert.
                                Reine Rechnung: ein Aufruf für den Erwartungswert von Z auf allen Qubits.
                                Bei qsim mit Ziehen ab 26 Qubits und bei 30 Qubits zwei Läufe statt fünf (CUDA-Q: drei).
  lauf_r41_nach.sh, ruhe.py     Nachmessung, siehe „Störung“ unten.
  auswertung_r41.py             liest ergebnis/*.json, schreibt auswertung.json und auswertung.txt.
  gen_dicht_41.py               erzeugt die zwei Tabellen der Webseite aus auswertung.json.

Ergebnis (ergebnis/): Rohdaten je Programm und Einstellung, die Protokolle der Abläufe, auswertung.txt mit beiden Tabellen.

Lesart. Unser Kern war schneller:
  mit 2.048 Messungen, ganzer Aufruf   gegen CUDA-Q in 35 von 35, gegen Lightning in 33 von 34, gegen qsim in 30 von 30 (qsim bis 28 Qubits)
  reine Rechnung                       gegen Lightning in 30 von 30 (bis 28 Qubits), gegen QuEST in 33 von 34, gegen qsim in 28 von 35
Nicht schneller war unser Kern:
  gegen qsim, reine Rechnung:      Ziegel zufällig, 20 Lagen, 24 Qubits; Ziegel zufällig, 20 Lagen, 26 Qubits; Ziegel zufällig, 20 Lagen, 28 Qubits; Ziegel zufällig, 20 Lagen, 30 Qubits; Quantum Volume, 26 Qubits; Quantum Volume, 28 Qubits; Quantum Volume, 30 Qubits
  gegen QuEST, reine Rechnung:     Eine Lage Hadamard, 16 Qubits
  gegen Lightning, mit Messungen:  Eine Lage Hadamard, 16 Qubits
  gegen CUDA-Q:                    keine
qsim rechnet mit einfacher Genauigkeit und halbem Speicher je Amplitude, unser Kern mit doppelter. Das ist kein gleicher Vergleich,
aber ein ehrlicher: qsim ist in diesen Schaltungen auf diesem PC schneller.
Prüfwert: Alle Programme liefern denselben Erwartungswert von Z auf allen Qubits (Abstände in auswertung.json).

Störung: Von 18:31 bis 18:44 Uhr und ab 19:29 Uhr lief auf dem Rechner eine fremde Rechnung mit acht Prozessen (anderes Projekt).
Sie traf Durchgang b unseres Kerns (18:32; bis zu doppelte Zeiten, Datei ergebnis/gestoert-kern-b.json, zählt nicht), qsim mit 2.048 Messungen
bis 24 Qubits und bei Lightning die Schaltungen nach 19:29. Diese Teile sind bei ruhigem Rechner neu gemessen (Dateien mit „nach“ im Namen,
Protokoll lauf_r41_nach.log mit der Belegung des Rechners vor und nach jedem Schritt); unser Kern dabei zweimal (Durchgänge c und d).
Die gestörten Dateien der anderen Programme liegen bei; weil für sie der schnellste Wert zählt, schaden sie ihnen nicht.
CUDA-Q, QuEST und qsim in der reinen Rechnung liefen außerhalb dieser Zeiten; ihre Werte stimmen im Median auf ein Prozent mit früheren Reihen überein.

Grenzen: eine Messreihe an einem Abend auf einem PC. qsim und QuEST sind von Hand gebaut, andere Compiler oder Schalter können andere Zeiten
geben. Nicht gemessen: CUDA-Q in einfacher Genauigkeit, Qulacs auf der Grafikkarte, Lightning mit Kokkos, QuEST mit cuQuantum,
Lightning in der reinen Rechnung bei 30 Qubits, qsim mit Messungen bei 30 Qubits, Lightning und QuEST bei Quantum Volume mit 30 Qubits.

Alles rechnet auf klassischer Hardware, kein Quantenvorteil.
Die Pfade in den Skripten (/home/coolblack/…) sind die unseres Rechners; der Quelltext des Kerns ist nicht enthalten.
