Az target erőforrásbecslő paramétereinek testreszabása

Ez a cikk bemutatja, hogyan szabhatja testre az target Azure Quantum Resource Estimator paramétereit a megcélzott gép jellemzőinek megfelelően. Az Erőforrásbecslő ezeket a paramétereket használja a kvantum-algoritmus kvantumszámítógépen való futtatásához szükséges erőforrások becslésére.

Előfeltételek

• Python-környezet, amelyen telepítve van a Python és a Pip .

• A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.

• VS Code az Azure Quantum Development Kit, Python és Jupyter bővítményekkel.

• A legújabb Azure Quantum qsharp és qsharp-widgets csomagok.

  python -m pip install --upgrade qsharp qsharp-widgets 
  

Target Paraméterek

Az Erőforrásbecslő kiszámítja az erőforrások becslését, például a qubitek számát és a futási időt, amely egy adott kvantumalgoritmus adott qubit-technológiával és rögzített architekturális választási lehetőségekkel való implementálásához szükséges.

Az erőforrásbecslő ezért bemenetek készletét használja előre definiált értékekkel a kezdéshez:

• Fizikai qubitmodell, amely meghatározza a mögöttes fizikai qubitek tulajdonságait.
• Kvantumhiba-korrekciós (QEC) séma, amely a feltételezett kvantumhiba-korrekciós séma.
• Hibakeret, amely az általánosan megengedett hiba, vagyis az a szám, ahányszor a programnak engedélyezve van a sikertelen leiratkozás.
• Az összetevő szintjén megkötések , amelyek a logikai ciklusok száma és a T-gyári példányok száma.
• Lepárlási egységek a T-gyárak desztillációs algoritmusainak megadásához.
• Pareto frontier estimate to run multiple estimates of number of qubits and runtime for the same algorithm.

Fizikai qubitparaméterek

Amikor az erőforrásbecslő modellezi a fizikai qubit-feltételezéseket, két különböző fizikai utasításkészletet használ a qubitek üzemeltetéséhez. A fizikai utasításkészlet lehet kapualapú vagy Majorana. A kapualapú utasításkészlet egy qubites mérést, egy qubites kaput (beleértve a T kapukat) és két qubites kapukat biztosít. A Majorana utasításkészlet fizikai T-kaput, egy qubites mérést és két qubites közös mérési műveleteket biztosít.

Hat előre definiált qubitparaméter közül választhat, amelyek közül négy kapualapú utasításkészlettel, kettő pedig Majorana utasításkészlettel rendelkezik. Ezek a qubitmodellek számos működési időt és hibaarányt fednek le, ami lehetővé teszi a gyakorlati kvantumalkalmazások engedélyezéséhez szükséges erőforrásköltségek megfelelő feltárását.

Előre definiált qubitparaméterek paraméterei

Referenciaként a teljes előre definiált qubitparaméterek a következők:

{
    "qubitParams": {
        "name": "qubit_gate_ns_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-3
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_ns_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-4
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e4",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "twoQubitJointMeasurementErrorRate": 1e-4,
        "tGateErrorRate": 0.05
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e6",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-6,
        "twoQubitJointMeasurementErrorRate": 1e-6,
        "tGateErrorRate": 0.01
    }
}

Előre definiált qubitparaméterek átadása

Az előre definiált qubitparaméterek programozott módon történő megadásának két módja van. Futtatáskor qsharp.estimatekiválaszthatja az qubitParams osztály qubitmodelljének nevét. Például a qubit paraméter kiválasztásához "qubit_maj_ns_e6" írja be a következőt:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e6"
                    },
                })

A qubitparamétereket az osztálynak is átadhatja a EstimatorParams használatávalQubitParams. Például a qubit paraméter kiválasztásához MAJ_NS_E6 írja be a következőt:

from qsharp.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E6 # qubit_maj_ns_e6 qubit parameter

qsharp.estimate("RunProgram()", params=params)

Előre definiált qubitparaméterek testreszabása

Az előre definiált qubitparaméterek testre szabhatók a név megadásával, majd a többi érték frissítésével. Ha például csökkenteni szeretné a két qubites közös mérés hibaarányát a "qubit_maj_ns_e4"-ban, írja be a következőt:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

Vagy egy lista formájában is átadhatja az utasításokat.

from qsharp.estimator import EstimatorParams, QubitParams

params = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Qubit-paraméterek a Gate-alapú qubitekhez

Az alábbi kód bemutatja, hogyan adható meg egyéni qubitparaméter egy kapualapú utasításkészlethez:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "gate_based"
params.qubit_params.t_gate_error_rate = 0.03
params.qubit_params.t_gate_time = "10 ns"
params.qubit_params.idle_error_rate = 0.02

Qubit-paraméterek Majorana qubitekhez

A Majorana-alapú utasításkészlet minimális sablonja az összes szükséges értékkel:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "majorana"
params.qubit_params.one_qubit_measurement_time = "10 ns"
params.qubit_params.one_qubit_measurement_error_rate = 0.01

two_qubit_joint_measurement_error_rateItt one_qubit_measurement_error_rate adhatja meg a mérési kiolvasásoknak és readouta mérésfeldolgozásnak processmegfelelő hibaarányokat. Ezek az értékek számok vagy számpárok lehetnek <double> . Például:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Kvantumhiba-korrekciós sémák

A gyakorlati léptékű kvantumalkalmazások végrehajtásához a kvantumműveletnek alacsony hibaarányúnak kell lennie. Ezek a hibaarányok targets általában túlmutatnak a nyers fizikai qubitek képességein. A korlátozás leküzdése érdekében a kvantumhibák javítása (QEC) és a hibatűrő számítások két kulcsfontosságú technika, amelyek a nagy léptékű kvantumszámítógépek építőelemeit alkotják. Először is a QEC lehetővé teszi, hogy több hibalehetőséget okozó fizikai qubitet írjunk, és egy megbízhatóbb logikai qubitet hozzunk létre, amely jobban megőrzi a kvantumadatokat, mint a mögöttes fizikai qubitek.

Az erőforrásbecslő a következő képletet használja a logikai hibaarányok exponenciális modellel való modellezéséhez,

$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

ahol $a$ egy keresztezési előtényező, $d$ a kód távolsága, $p$ a fizikai hibaarány, $p^*$ pedig a kvantumhibák korrekciós küszöbértéke. A $a$ keresztezési előtényező numerikusan kinyerhető szimulációkhoz.

A kód távolsága $d$ egy olyan paraméter, amely szabályozza a kijavítható hibák számát. Így a kód távolsága határozza meg a logikai qubitek hibaarányát és a kódolásukhoz szükséges fizikai qubitek számát. A pontosság és a fizikai qubitek száma is növekszik a kód távolságával. A QEC-sémák célja, hogy megtalálják azt a minimális kódtávolságot, amely képes elérni az adott alkalmazáshoz beállított szükséges hibaarányt.

A fizikai hibaarány $p$ a qubit paramétereiből nyerhető ki az eszközön végrehajtott fizikai Clifford-művelet legrosszabb esetbeni hibaarányaként. Különösen $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, ) two_qubit_gate_error_ratea kapualapú utasításkészlettel rendelkező qubitparaméterekhez, és $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) a Majorana utasításkészlettel rendelkező qubitparaméterekhez. A QEC-sémák általában hibaarány-küszöbértéket $p^*$ érték alatt, amely alatt a hibajavítás elnyomja a hibákat.

Az Azure Quantum Resource Estimator két előre definiált QEC-sémát támogat: egy felületi kódot és egy floquet-kódot.

Előre definiált QEC-sémák paraméterei

Az előre definiált QEC-sémák pontos paraméterei a következők.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Előre definiált QEC-sémák átadása

Az előre definiált QEC-sémák kétféleképpen határozhatók meg. Futtatáskor qsharp.estimatekiválaszthatja az "qecScheme" osztály QEC-modelljének nevét. A floquet kód kiválasztásához például írja be a következőt:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

A becslési paraméterek listáját is átadhatja az EstimatorParams osztálynak az QECScheme osztály használatával. A floquet kód kiválasztásához például írja be a következőt:

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.qec_scheme.name = QECScheme.FLOQUET_CODE # floquet code QEC scheme

qsharp.estimate("RunProgram()", params=params)

Előre definiált QEC-sémák testreszabása

Az előre definiált QEC-sémákat testre szabhatja a név megadásával, majd a többi érték frissítésével. Ha például növelni szeretné a keresztezési előtényezőt a floquet-kódban, írja be a következőt:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

A QEC-sémák testreszabása

Az erőforrásbecslő a fenti képleten alapuló testreszabott QEC-sémát absztrakcióra képes a $a$ és a "crossingPrefactor" "errorCorrectionThreshold" $p^*$ értékének megadásával. Emellett meg kell adnia az "logicalCycleTime"egyetlen logikai művelet végrehajtásának idejét, amely a kód távolságától és a mögöttes fizikai qubitek fizikai műveleti idő feltételezésétől függ. Végül egy második képlet kiszámítja az "physicalQubitsPerLogicalQubit"egy logikai qubit kódolásához szükséges fizikai qubitek számát a kód távolsága alapján.

A következő kódot használhatja sablonként a QEC-sémákhoz:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })                

A képleteken belül használhatja azokat a változókat one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timeés two_qubit_joint_measurement_time, amelyek értékei a megfelelő mezőből származnak a fizikai qubit paramétereiből, valamint a logikai qubithez kiszámított kódtávolság változóját eccDistance a fizikai qubit tulajdonságai, a hibajavítási küszöbérték és a keresztezési előbontás alapján. Az időváltozók, és eccDistance a képlet leírására logicalCycleTime használhatók. A képlethez physicalQubitsPerLogicalQubit csak a eccDistance képlet használható.

Hiba a költségvetésben

A teljes hibakeret $\epsilon$ az algoritmus általánosan tolerált hibáját állítja be, vagyis az algoritmus megengedett hiba valószínűségét. A globális értéknek 0 és 1 közöttinek kell lennie, az alapértelmezett érték pedig 0,001, amely 0,1%-nak felel meg. Más szóval az algoritmus 1000 végrehajtás során legfeljebb egyszer hiúsulhat meg. Ez a paraméter kifejezetten alkalmazásspecifikus.

Ha például Shor-algoritmust futtat egész számok faktorálásához, a hibakeret nagy értéke eltűrhető, mivel ellenőrizheti, hogy a kimenetek valóban a bemenet elsődleges tényezői-e. Másfelől kisebb hibakeretre lehet szükség ahhoz, hogy egy algoritmus megoldjon egy megoldással kapcsolatos problémát, amelyet nem lehet hatékonyan ellenőrizni.

A hibakeret három rész összegének felel meg:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

A $\epsilon_{\log}$ logikai hibák a logikai qubitek implementálásának hibája, a $\epsilon_{\rm dis}$ T állapothiba a T-állapotok lepárláson keresztüli előállításának hibája, a $\epsilon_{\rm syn}$ forgatókapuhiba pedig a forgókapuk tetszőleges szögekkel történő szintetizálásának hibája.

Vegye figyelembe, hogy a lepárlás és a forgásszintézis esetében a $\epsilon_{\rm dis}$ és a $\epsilon_{\rm syn}$ hibakeretek egységesen vannak elosztva az összes szükséges T-állam és az összes szükséges forgatókapu között. Ha a bemeneti algoritmusban nincsenek rotációs kapuk, a hibakeret egységesen logikai hibákra és T-állapothibákra oszlik.

Hibakeret átadása

A hibakeret kétféleképpen határozható meg, ha 0 és 1 közötti számot ad meg. Futtatáskor qsharp.estimateátadhatja a hibakeretet. Ha például egy 1/3-as hibakeretet szeretne kiválasztani, írja be a következőt:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

A hiba tervezett paramétereit az osztálynak EstimatorParamsis átadhatja.

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.error_budget = 0.333 # error budget of 1/3

qsharp.estimate("RunProgram()", params=params)

Emellett külön-külön is megadhatja a hibakeret minden összetevőjét. Az összes érték összege a teljes hibakeret, és 0 és 1 között kell lennie. Ha egy kvantum-algoritmus nem tartalmaz T állapotokat vagy forgásokat, akkor az értékek t_states rotations 0 vagy 0 lehetnek.

Az alábbi kód bemutatja, hogyan adhatja meg a hiba tervezett paraméterét T állapotokkal és forgatásokkal:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()
params.error_budget.logical = 0.01
params.error_budget.t_states = 0.02
params.error_budget.rotations = 0.03

Megszorítások

Az "constraints" osztály használatával korlátozásokat alkalmazhat a T-gyári összetevő szintjén. A korlátozások módosításával optimalizálhatja a becsléseket a qubitek számának csökkentése vagy a futtatókörnyezet csökkentése érdekében.

Az alábbi kód bemutatja, hogyan adhatja meg a kvantum-algoritmusok korlátait:

from qsharp.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

Desztillációs egységek

Az osztályban megadhatja a T-gyárak desztillációs algoritmusainak specifikációit.DistillationUnitSpecification A specifikáció lehet előre definiált vagy egyéni. Előre definiált specifikációt a desztillációs egység nevének kiválasztásával adhat meg: 15-1 RM vagy 15-1 space-efficient.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.name = "15-1 RM" # predefined distillation unit

params.distillation_unit_specifications.append(unit)

Mindkét esetben a 15-1 jelölés 15 bemeneti T állapotot és 1 kimeneti T állapotot jelent. A 15-1 space-efficient lepárlási egység kevesebb qubitet használ, mint 15-1 RM amennyit használ, de több futtatókörnyezetet igényel. További információkért lásd a VI. táblázatot.

A desztillációs egységek testreszabása

Testre szabhatja saját desztillációs egységeit. A desztillációs egységek pontos paraméterei a következők.

qsharp.estimate("RunProgram()", params=
                    {"distillationUnitSpecifications": {
                        "displayName": <string>, 
                        "numInputTs": <int>,
                        "numOutputTs": <int>,
                        "failureProbabilityFormula": <string>,
                        "outputErrorRateFormula": <string>,
                        "physicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecificationFirstRoundOverride": <protocol specific parameters>, # Only if "logicalQubitSpecification"
                        }
                })

A numerikus paraméterek várhatóan pozitívak lesznek. Megadja displayName , hogy a lepárlási egység hogyan jelenjen meg a kimeneti eredményekben.

Az alábbi kód bemutatja, hogyan adhatja meg a desztillációs egység paramétereit egy kvantum-algoritmushoz az osztály és az DistillationUnitSpecification ProtocolSpecificDistillationUnitSpecification osztály használatával.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

A képletek failure_probability_formula output_error_rate_formula olyan egyéni képletek, amelyek alapszintű aritmetikai műveleteket, állandókat és csak három paramétert használnak:

• clifford_error_rate, más néven c.
• readout_error_rate, más néven r.
• input_error_rate, más néven z.

Tekintse meg az alábbi példákat az egyéni képletekre hosszú és rövid jelöléssel. Ezek a példák a standard implementációban alapértelmezés szerint használt képleteket szemléltetik.

Legalább egy paramétert physical_qubit_specification logical_qubit_specification meg kell adni. Ha csak az előbbi van megadva, a desztillációs egység alkalmazható fizikai qubitekre. Ha csak az utóbbi van megadva, a lepárlási egység alkalmazható logikai qubitekre. Ha mindkettő rendelkezésre áll, a desztillációs egység mindkét qubittípusra alkalmazható.

A paraméter logical_qubit_specification_first_round_override csak akkor adható meg, ha logical_qubit_specification meg van adva. Ha igen, felülbírálja a lepárlás első fordulójában alkalmazott eset értékeit logical_qubit_specification . A szükséges értéknek <protocol specific parameters> logical_qubit_specification_first_round_override követnie kell a sémát:

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Pareto határbecslés

Egy algoritmus erőforrásainak becslésekor fontos figyelembe venni a fizikai qubitek száma és az algoritmus futtatókörnyezete közötti kompromisszumot. Az algoritmus futásidejének csökkentése érdekében fontolja meg a lehető legtöbb fizikai qubit lefoglalását. A fizikai qubitek számát azonban a kvantumhardverben elérhető fizikai qubitek száma korlátozza. Az erőforrás-becslés egyik legfontosabb aspektusa a futtatókörnyezet és a rendszerméret közötti kompromisszum megértése.

A Pareto-határbecslés több becslést is biztosít ugyanahhoz az algoritmushoz, amelyek mindegyike a qubitek száma és a futtatókörnyezet közötti kompromisszumokat mutatja.

Ha a Pythonban futtatja az Erőforrásbecslőt, a paramétert a "estimateType" következőképpen kell megadnia "frontier": .

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Ha a Pareto-határbecslés eredményeit szeretné vizualizálni, használhatja a függvényt EstimatesOverview . Ez a függvény a határbecslés eredményeit jeleníti meg táblázatban és egy téridő-diagramban. További információ: Téridő diagram.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Következő lépések

• Az erőforrásbecslő eredményeinek megismerése
• Az első erőforrás-becslés futtatása
• Az erőforrásbecslő futtatásának különböző módjai
• Nagyméretű programok kezelése az Erőforrás-becsléssel
• Oktatóanyag: Kvantumkémia-probléma erőforrásainak becslése