← Atlas

Algorithms · Optimization · Ising encoding

Quantum vulnerability analysis for patch prioritization

Given a network's vulnerabilities and how their connectivity creates kill-chains — paths to security compromise — decide which vulnerabilities to prioritize for patching, so that those paths are removed.

Attested & literatureUpdated

View frozen graph

  • Record typeLiterature reference
  • Reference implementationpatching_management
  • Reported costNo proven asymptotic bound. The paper reports, as an experimental finding for vulnerability graphs of the density expected in the real world, that the quantum computer's solve time is almost constant while the classical solve time increases exponentially; the abstract gives no formula, no growth rate, and no qubit, gate, or annealing-time count for either quantity.
  • Papers1

This record, used inside a worked example

This page says as a QUBO and solving it with quantum annealing — here is a concrete, runnable instance of it.

QAOA, p=1, MaxCut on a 4-cycle

4 qubits on a 4-cycle (edges 0-1, 1-2, 2-3, 3-0), one QAOA layer with gamma=pi/8, beta=3*pi/8.

q0q1q2q3Hadamard layer(4)QAOA MaxCut layer

Where it ends up

  • 010127%
  • 101027%
  • 00118%
  • 01108%
  • 12 more outcomes31%

0101 and 1010 are the two optimal cuts of a 4-cycle (alternating around the ring); at these angles measuring the register returns one of them clearly more often than any other cut.

Open that example in Studio

Quantum vs classical

Classical baseline

Compare Optimization · Ising encoding with the strongest classical method for the same instance, input budget, and output metric.

Quantum claim

This reference exposes a quantum circuit pattern; it does not imply an application-level speedup without a matched benchmark.

How to compare

Report input loading, circuit depth, repetitions, classical preprocessing, post-processing, and wall-clock time together.

References

  • Cutting Medusa's Path -- Tackling Kill-Chains with Quantum Computing

    Mark Carney · 2022

    Primary source: it introduces vulnerability graphs, related to attack graphs, as the background for a QUBO-and-quantum-annealing method that prioritizes patches, proves that the resulting solution removes all kill-chains on a network, and reports that the quantum computer's solve time is almost constant against exponentially increasing classical solve time for vulnerability graphs of real-world density. Consult it for the proof, the formal definition of a kill-chain, and how a vulnerability graph is built from a network — none of which the abstract states.

Attested & literature
  • Peer-reviewed paper
Method
Curation only. This record documents the algorithm a published reference implementation demonstrates, not the demonstration itself: nothing in Leona runs Qmod. The primary reference's title, authors and submission year were read from its arXiv abs page, and the complexity claim taken from a clause of that paper's abstract (The abstract of arXiv:2211.13740 states no big-O expression or resource count. Its cost claim is "The results demonstrate that the quantum computer's solve time is almost constant compared to the exponential increase in classical solve time for vulnerability graphs of expected real world density." That is reported as a finding, not derived as a formula: no growth rate, no constant, and no qubit, gate, or annealing-time count accompanies it anywhere in the abstract. The same abstract separately states, "Such a solution is then proved to remove all kill-chains (paths to security compromise) on a network." That is a correctness claim about coverage, not a cost bound, and is not treated as a complexity figure here. The demonstration this record covers states no complexity bound of its own. Those are the only sources read for this field, and the complexity field above is left as a qualitative finding rather than filled with a numeric bound written from memory.). No circuit was constructed, simulated or run.
Result
Pass · the record's problem statement and primary reference agree with the sources named above.
Caveat
This is a literature record. Nothing was built, compiled, simulated, run or measured for it: no vulnerability graph was constructed, no QUBO was formed or solved, and no quantum annealer or classical solver was run for this record. It documents the algorithm the paper describes and does not reproduce or verify the demonstration at applications/cybersecurity/patching_management; the pinned index read for this record gives only that directory path and the file list patch_min_vertex_cover.ipynb and patch_min_vertex_cover.qmod, nothing about what those files contain. The near-constant-versus-exponential solve-time finding is the paper's own reported result, stated for vulnerability graphs of the density expected in the real world; it is an experimental finding, not a proven asymptotic bound, and the abstract gives no formula, no growth rate, no problem-size variable, and no qubit, gate, or annealing-time count to go with it, so none of those figures is repeated here. The claim that the QUBO solution removes all kill-chains is stated by the abstract as proved, but the abstract does not say what the proof assumes, what counts as a kill-chain in the formal model, or how a vulnerability graph is built from a real network, so this record states none of that either. The abstract does not name what hardware or simulator produced the reported quantum-computer solve time, and this record does not guess at it. There is no comparison here against any state of the art beyond the classical baseline the paper itself measured against, and that comparison is the paper's own, not verified or repeated for this record.
Cutting Medusa's Path -- Tackling Kill-Chains with Quantum Computing ↗
Kind
curated reference
Reviewed by
Leona Quantum curation pass
License
Citation metadata only; source publication terms apply
vulnerability graphsquboquantum annealingkill-chain eliminationpatch prioritization

Atlas stars stay in the public catalog. Saving this entry to your workspace starts an unstarred private copy.