⚛️ quantum physics

How Many Shots Does It Take? A Noise-Aware Quantum Resource Allocation Framework

Dit artikel stelt een ruisbewust raamwerk voor met een gesloten analytisch model en een optimale shot-allocatietechniek die het aantal shots voor de uitvoering van kwantumalgoritmen, het energieverbruik en de totale fout aanzienlijk vermindert in vergelijking met de huidige praktijken.

Oorspronkelijke auteurs: Prateek P. Kulkarni, Sumit K. Mandal

Gepubliceerd 2026-07-28

📖 8 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Prateek P. Kulkarni, Sumit K. Mandal

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een geheim bericht probeert te sturen door een zeer lawaaierige kamer. Als je slechts één keer fluistert, kan de persoon aan de andere kant "appel" horen terwijl je eigenlijk "abrikoos" zei. Om er zeker van te zijn dat ze het juiste woord hebben begrepen, zou je de boodschap misschien honderd keer kunnen schreeuwen. Als 60 mensen "appel" horen en 40 mensen "abrikoos", kun je de waarheid raden. In de wereld van quantumcomputing wordt dit "schreeuwen" een shot genoemd. Een quantumcomputer is een machine die de vreemde regels van minuscule deeltjes gebruikt om problemen op te lossen, maar hij is ongelooflijk gevoelig voor ruis — zoals een fluistering in een orkaan. Daarom moeten wetenschappers dezelfde berekening keer op keer uitvoeren (veel shots nemen) om een betrouwbaar antwoord te krijgen. Het probleem is dat elke keer dat je een berekening uitvoert op een echte quantumcomputer, dit geld kost, tijd kost en veel energie verbruikt. Dus, de grote vraag voor iedereen die deze machines wil gebruiken is: "Hoe vaak moet ik eigenlijk schreeuwen om zeker te weten dat ik het goed heb?" Als je te weinig schreeuwt, krijg je rommel. Als je te veel schreeuwt, verspil je middelen en ben je misschien door je tijd of geld heen voordat je klaar bent.

Dit is precies het puzzelstukje waar Prateek P. Kulkarni en Sumit K. Mandal een oplossing voor zoeken in hun paper, "How Many Shots Does It Take?". Ze realiseerden zich dat mensen momenteel vaak gokken hoeveel shots ze moeten nemen, waarbij ze vaak veel te veel schreeuwen om maar veilig te zitten. De auteurs hebben een nieuw, op wiskunde gebaseerd "recept" ontwikkeld dat je het exacte aantal keren vertelt dat je een quantumberekening moet uitvoeren om een betrouwbaar resultaat te krijgen, gebaseerd op hoe specifiek jouw computer ruisig is. Denk aan een weer-app die niet alleen zegt "het kan gaan regenen", maar je precies vertelt hoeveel regenjassen je moet kopen op basis van de luchtvochtigheid en windsnelheid.

Maar er is een tweede wending. Soms is een quantumprobleem zo groot dat de computer het niet in één keer kan oplossen. Het is alsof je een enorme piano een trap op probeert te dragen die te smal is; je moet de piano in stukken hakken, de stukken één voor één naar boven dragen en ze vervolgens weer in elkaar zetten. De auteurs ontdekten dat het een slecht idee is om simpelweg elke stuk van de piano evenveel inspanning te geven (hetzelfde aantal shots). Sommige stukken zijn zwaarder of gladder (ruisiger) dan andere. Hun nieuwe methode berekent precies hoe je je "schreeuwwbudget" verdeelt, zodat de gladde stukken extra aandacht krijgen, terwijl de gemakkelijke stukken net genoeg krijgen.

In hun experimenten hebben ze dit idee getest op echte quantumcomputers van IBM. Ze ontdekten dat ze door hun nieuwe formule te gebruiken, het aantal benodigde shots met ongeveer 58% konden verminderen vergeleken met de huidige praktijken. Dit is niet zomaar een kleine besparing; het betekent dat ze tot wel 62% minder energie verbruiken. Bovendien, toen ze grote problemen in stukken braken en hun slimme verdeelstrategie gebruikten, verminderden ze de totale fouten in het uiteindelijke antwoord met wel 73% vergeleken met de oude manier van doen (met een gemiddelde reductie van 63%). Ze gokten niet alleen; ze draagden hun algoritmen uit op echte hardware en bewezen dat hun wiskunde overeenkomt met de realiteit, waarbij hun voorspellingen ongeveer 98% accuraat waren voor het tellen van shots en 95% accuraat voor het bepalen hoe diep een berekening kan gaan voordat de computer te verward raakt.

Het Verhaal van de Ruisende Fluistering

Om te begrijpen waarom dit ertoe doet, laten we kijken naar hoe quantumcomputers werken. In tegenstelling tot je laptop, die bits gebruikt die ofwel 0 of 1 zijn, gebruiken quantumcomputers "qubits" die tegelijkertijd een mix van beide kunnen zijn. Dit maakt ze superkrachtig, maar ook super kwetsbaar. Het moment dat ze met de buitenwereld in interactie komen, worden ze "ruisig" en verliezen ze hun speciale staat. Om dit te herstellen, voeren wetenschappers hetzelfde programma keer op keer uit. Elke uitvoering is een "shot".

Stel je voor dat je probeert de gemiddelde lengte van een groep mensen te raden, maar je kunt ze alleen door een beslagen raam zien. Als je één keer kijkt, denk je misschien dat ze allemaal reuzen zijn. Als je tien keer kijkt, krijg je misschien een beter idee. Als je duizend keer kijkt, weet je de gemiddelde lengte heel precies. Maar duizend keer kijken kost veel tijd en maakt je ogen moe. De auteurs vroegen zich af: "Wat is het minimale aantal keren dat ik moet kijken om voor 95% zeker te weten dat ik het goed heb?"

Ze ontdekten dat het antwoord afhangt van twee dingen: hoe goed je ogen zijn (de kwaliteit van de computer) en hoe dik de mist is (de ruis). Ze schreven een closed-form vergelijking op — één enkele, nette wiskundige formule — die de specificaties van de computer neemt (zoals hoe lang een qubit duurt voordat hij vervaagt, bekend als $T_1$ en $T_2$ ) en je het exacte aantal shots vertelt dat nodig is. Voorheen kozen mensen vaak gewoon een willekeurig hoog aantal om veilig te zijn, wat hetzelfde is als een boodschap 1.000 keer schreeuwen terwijl 400 keer genoeg zou zijn geweest.

De Puzzel van de Gebroken Piano

Stel je nu voor dat je een quantumprobleem hebt dat te groot is voor de computer om in één keer vast te houden. De computer heeft een "dieptegrens", wat lijkt op een maximaal aantal stappen dat het kan zetten voordat het te moe wordt en fouten maakt. Als je probleem 1.200 stappen heeft, maar de computer kan er slechts 285 aan, moet je het probleem in kleinere brokken verdelen.

De oude manier om dit te doen was om het probleem in stukken te hakken en elk stuk evenveel shots te geven. De auteurs argumenteerden dat dit hetzelfde is als een zware, gladde doos en een lichte, droge doos evenveel hulp geven bij het naar boven dragen van een heuvel. De zware doos heeft meer hulp nodig! In de quantumwereld zijn sommige delen van het circuit "ruisiger" dan andere. Als je de ruisige delen niet extra shots geeft, zal het uiteindelijke antwoord fout zijn.

De auteurs ontwikkelden een nieuwe strategie met behulp van een wiskundig hulpmiddel genaamd "Lagrange-multipliers" (denk aan dit als een super-slimme rekenmachine die een weegschaal in evenwicht houdt). Ze ontdekten dat je meer shots moet geven aan de delen van het circuit die ruisiger zijn en minder shots aan de stille delen. Ze bewezen dat deze methode de totale fout minimaliseert.

Wat Ze Vonden

Toen de auteurs hun ideeën testten op echte IBM-quantumcomputers (specifiek de Marrakesh, Torino en Fez modellen), waren de resultaten indrukwekkend.

De Shot Count: Hun formule voorspelde het aantal benodigde shots met ongeveer 98,2% nauwkeurigheid. Bijvoorbeeld, toen ze het Quantum Fourier Transform (QFT) algoritme testten, zat hun voorspelling er slechts ongeveer 1,87% naast. Dit betekent dat ze je precies kunnen vertellen hoe vaak je je code moet draaien zonder tijd te verspillen.
De Energiebesparing: Omdat ze het aantal benodigde shots met gemiddeld 58% verminderden, verminderden ze ook het energieverbruik. In hun tests bespaarden ze tot wel 62% van de energie per 1.000 shots. Dat is alsof je een auto rijdt die plotseling 60% beter in verbruik is.
De Foutreductie: Wanneer ze grote problemen in stukken braken en hun slimme toewijzingsstrategie gebruikten, verminderden ze de totale fout met gemiddeld 63% vergeleken met de standaardmethode van "gelijke verdeling". In de beste gevallen bereikte de foutreductie wel 73%.

Ze controleerden ook hoe diep een circuit kon gaan voordat het te ruisig werd om te gebruiken. Hun wiskunde voorspelde deze "maximale diepte" met ongeveer 95% nauwkeurigheid. Dit helpt wetenschappers om precies te weten hoe groot een probleem ze kunnen oplossen op een specifieke machine voordat ze zelfs maar beginnen met coderen.

Waarom Dit Ertoe Doet

Het paper biedt niet alleen een nieuwe theorie; het biedt een praktisch hulpmiddel voor het huidige tijdperk van quantumcomputing, vaak de "Noisy Intermediate-Scale Quantum" (NISQ) era genoemd. Op dit moment zijn quantumcomputers duur en moeilijk toegankelijk. Elke keer dat een onderzoeker een taak uitvoert, verbruikt hij geld en tijd. Door dit "ruis-bewuste" kader te gebruiken, kunnen onderzoekers stoppen met gokken en beginnen met rekenen. Ze kunnen hun algoritmen draaien met minder shots, energie besparen en nauwkeurigere resultaten krijgen.

De auteurs hebben aangetoond dat we, door simpelweg de ruis te begrijpen en middelen verstandig te verdelen, de quantumcomputers veel nuttiger kunnen maken voor vandaag, nog voordat we de perfecte, foutloze machines van de toekomst hebben. Het is een herinnering dat de beste manier om vooruit te gaan soms niet is om een grotere machine te bouwen, maar om de machine die we hebben veel slimmer te gebruiken.

Technische Samenvatting: Een Ruisbewust Quantum Resource Allocatie Framework

Probleemstelling

De praktische uitvoering van quantumalgoritmen op nabije-termijn quantumcomputers wordt ernstig beperkt door hardware-ruis, beperkte gate-fideliteiten en de noodzaak van herhaalde circuit-uitvoeringen (shots) om betrouwbare statistische resultaten te verkrijgen. Huidige benaderingen kampen met twee primaire inefficiënties:

Shot-schatting: Onderzoekers vertrouwen vaak op klassieke simulaties met geïdealiseerde ruismodellen of empirische trial-and-error op echte hardware, wat leidt tot ofwel onbetrouwbare voorspellingen ofwel excessieve shot-aantallen die computationele middelen en energie verspillen.
Resource Allocatie: Wanneer diepe circuits de hardware-dieptegrenzen overschrijden, moeten ze worden opgedeeld in kleinere sub-circuits. Conventionele strategieën verdelen het totale shot-budget doorgaans gelijkmatig over deze partities. Deze "gelijke allocatie" negeert de specifieke ruisvarianties, circuitdieptes en qubit-resources van individuele sub-circuits, wat leidt tot suboptimale foutaccumulatie en hogere totale schattingsfouten.

De kernuitdaging is het bepalen van het exacte aantal shots dat vereist is voor een doelstelling van succeswaarschijnlijkheid en het optimaal verdelen van een vast shot-budget over circuit-partities om de totale fout te minimaliseren, terwijl rekening wordt gehouden met specifieke hardware-ruisparameters.

Methodologie

De auteurs stellen een verenigd, ruisbewust framework voor bestaande uit drie analytische stadia, geïllustreerd in Figuur 2 van het artikel:

1. Closed-Form Shot Schatting

Het framework leidt een closed-form analytische expressie (Vergelijking 6) af om het optimale aantal shots ( $s$ ) te berekenen dat vereist is om een doelstelling van succeswaarschijnlijkheid ( $P(s)$ ) te bereiken.

Modellering: Het succes van shots wordt gemodelleerd met behulp van een Bernoulli-toevalsvariabele met een maximale fideliteit ( $F_{max}$ ). De totale succeswaarschijnlijkheid wordt gedefinieerd via een meerderheidsstem-criterium ( $P(S_n \geq s/2)$ ).
Ruisintegratie: Het model incorporeert hardware-ruisparameters, waaronder decoherentietijden ( $T_1, T_2$ ), gate-foutkansen ( $p_g$ ) en circuit-executietijd ( $t_{circ}$ ). Deze factoren dragen bij aan een ruisvariantie-term ( $\sigma^2_{noise}$ ) afgeleid van fysieke coherentiemodellen (Vergelijking 7).
Resultaat: Door $s$ op te lossen met behulp van de inverse foutfunctie, biedt het framework een exacte formule om het benodigde shot-aantal voor betrouwbaarheid te bepalen, waardoor heuristische oversampling wordt geëlimineerd.

2. Maximale Diepte en Partitiering

Gebruikmakend van de afgeleide shot-ruisrelatie, berekent het framework de maximale uitvoerbare circuitdiepte ( $d_{max}$ ) die een specifieke quantumdevice kan ondersteunen terwijl de doelstelling van betrouwbaarheid behouden blijft (Vergelijking 9).

Partitieringslogica: Als de oorspronkelijke diepte van een algoritme ( $d_{original}$ ) groter is dan $d_{max}$ , berekent het framework het minimale aantal partities ( $m$ ) dat vereist is (Vergelijking 10). Dit zorgt ervoor dat elk sub-circuit binnen de fidelity-limieten van de hardware opereert.
Restrictie: De afleiding gaat ervan uit dat partities zo gebalanceerd mogelijk zijn, waarbij de maximale partitie-diepte volgens het duivenhokprincipe ten minste $d_{original}/m$ moet zijn.

3. Optimale Shot Allocatie

Gegeven een vast totaal shot-budget ( $S$ ) en $m$ partities, formuleert het framework een optimalisatieprobleem om shots ( $s_i$ ) over partities te verdelen om de totale gekwadrateerde schattingsfout ( $E = \sum \sigma^2_i / s_i$ ) te minimaliseren.

Optimalisatie: Met behulp van Lagrange-multiplicatoren leiden de auteurs een exacte allocatieformule af (Vergelijking 12).
Strategie: De optimale strategie wijst shots proportioneel toe aan de ruisvariantie ( $\sigma_i$ ) van elke partitie. Partities met hogere ruis (door diepte, aantal qubits of hardware-imperfecties) ontvangen meer shots, terwijl partities met lagere ruis minder ontvangen. Dit staat in contrast met conventionele gelijke allocatie, die deze varianties negeert.

Belangrijkste Bijdragen

Analytische Shot Expressie: Een closed-form vergelijking die het aantal shots relateert aan de succeswaarschijnlijkheid, waarbij expliciet rekening wordt gehouden met hardware-ruisparameters ( $T_1, T_2, p_g, F_{max}$ ).
Optimale Allocatiestrategie: Een theoretisch onderbouwde techniek om een vast shot-budget over circuit-partities te verdelen. De methode minimaliseert de totale fout door shots toe te wijzen die proportioneel zijn aan de ruisvariantie van elke partitie.
Verenigd Framework: Een systematische workflow die shot-schatting, diepteberekening, partitiering en resource-allocatie integreert, waarmee de kloof tussen hardwarebeperkingen en algoritmische vereisten wordt overbrugd.

Experimentele Resultaten

Het framework werd geëvalueerd op vijf quantumalgoritmen (QFT, QST, VQE, QAOA, Shor's) op drie IBM Quantum-processors (Marrakesh, Torino, Fez).

Modelnauwkeurigheid:
- De analytische shot-schatting (Eq. 6) bereikte een gemiddelde nauwkeurigheid van 98,2% vergeleken met experimentele resultaten op IBM Marrakesh.
- De maximale diepteschatting (Eq. 9) bereikte een gemiddelde nauwkeurigheid van 95%.
Shot Reductie: Vergeleken met de huidige praktijken (conservatieve oversampling), vermindert de voorgestelde techniek het totale aantal benodigde shots voor betrouwbare uitvoering met ongeveer 58%.
Foutreductie: Bij het verdelen van een vast shot-budget vermindert de optimale allocatiestrategie de totale schattingsfout met tot wel 73% (en een gemiddelde van 63% wanneer gecombineerd met geautomatiseerde circuit cutting) vergeleken met conventionele gelijke-shot-allocatie.
Energie-efficiëntie: Door het aantal shots te verminderen, reduceert het framework het energieverbruik met tot wel 62% (gemiddeld 59%), waarbij rekening wordt gehouden met het volledige stack-stroomverbruik inclusief cryogene koeling.

Betekenis en Claims

Het artikel claimt het eerste verenigde framework te bieden dat exacte closed-form expressies afleidt voor:

Het optimale aantal shots dat vereist is voor een gegeven betrouwbaarheid.
De maximale circuitdiepte die een quantummachine kan ondersteunen op basis van fundamentele hardwareparameters.
De optimale distributie van een shot-budget over circuit-partities om de executiefout te minimaliseren.

De auteurs benadrukken dat dit werk verder gaat dan heuristische of adaptieve methoden door een theoretisch onderbouwd, ruisbewust analytisch model te bieden. Door de noodzaak van "verspillende over-provisioning" van shots te elimineren en de distributie van resources te optimaliseren, maakt het framework complexe quantumalgoritmen praktischer en economisch levensvatbaarder op de huidige Noisy Intermediate-Scale Quantum (NISQ) devices. De resultaten suggereren dat significante verbeteringen in betrouwbaarheid en energie-efficiëntie kunnen worden bereikt zonder nieuwe hardware te vereisen, simpelweg door te optimaliseren hoe bestaande resources worden toegewezen.