Procedural Generation and Games at the Dawn of Fault Tolerant Quantum Computing

Daniel Bultrini; James Wootton

REVIEW 2 major objections 5 minor 37 references

Procedural Generation and Games at the Dawn of Fault Tolerant Quantum Computing

T0 review · 2 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims that a concrete game called Knotty Jones, scoring knots via the Jones polynomial, is classically impossible but quantum-feasible on early fault-tolerant computers.

desk verdict Readable vision paper with a clever game idea, but its flagship runtime/scaling claim for the Jones polynomial is unverified and contradicts the paper’s own end-to-end standard. read the letter →

arxiv 2508.09683 v1 pith:LOXKKSS5 submitted 2025-08-13 quant-ph

Daniel Bultrini , James Wootton This is my paper

classification quant-ph

keywords quantumcomputingfault-tolerantcomputersproceduralcontentgenerationJonespolynomialadvantagegamesconstraintsatisfactionknottheory

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Quantum computers have mostly been research toys, but this paper argues that the coming generation of fault-tolerant machines will find a practical home in game development, specifically in procedural content generation—the algorithmic creation of game worlds, levels, and rules. The paper surveys classical PCG techniques (constraint satisfaction, evolutionary algorithms, grammars, cellular automata, machine learning) and pairs each with candidate quantum algorithms, noting where speedups are proven, plausible, or absent. Its sharpest claim is a game concept called Knotty Jones, where a player battles knots and wins by matching the opponent's Jones polynomial—a quantity that is #P-hard to compute classically but, according to the cited quantum algorithm, computable in about a minute on a fault-tolerant quantum computer with a runtime that barely grows with knot complexity. If that holds, the game is a concrete, in-game quantum advantage rather than a hardware demo.

What carries the argument

The load-bearing machinery is the end-to-end quantum algorithm of Ref. [16] for the Jones polynomial, which the paper treats as a black box that takes a knot and returns its Jones polynomial in logarithmic time (or roughly one minute for practically large knots) on a fault-tolerant quantum computer. Around it, the game wraps two classical knot operations: Reidemeister moves, which preserve the invariant, and link inversions, which change it. The algorithm's supposed logarithmic scaling is what makes live queries to a quantum coprocessor plausible even during gameplay, and it is the property that would make Knotty Jones classically infeasible at high complexity.

What would settle it

Run the end-to-end Jones-polynomial algorithm on an actual fault-tolerant quantum computer for knots with increasing crossing numbers. If the measured wall-clock time grows faster than logarithmically—or if a knot that defeats a classical A100 (memory-limited at about 1500 crossings in 5 minutes) cannot be scored in about one minute on the quantum machine—the paper's feasibility claim collapses.

Watch

Extended reading notes

Core claim

The central proposal of this vision paper is that procedural content generation is the most promising early-FTQC application in games, and that a specific proof-of-principle game can exploit a real quantum advantage today's machines cannot offer. In Knotty Jones, the player performs Reidemeister moves (which do not change the Jones polynomial) and link inversions (which do), and a quantum coprocessor computes the resulting Jones polynomial to decide the round. The paper repeats the cited algorithm's claim that this computation takes roughly one minute on a superconducting fault-tolerant quantum computer and that the runtime stays similar for much larger knots because of logarithmic scaling,

Load-bearing premise

The whole proposal leans on the assumption that the quantum Jones-polynomial algorithm keeps its logarithmic runtime and roughly one-minute wall-clock time on a real fault-tolerant machine once error correction, input loading, and output decoding are counted.

Editorial extensions

If this is right

If the Jones polynomial runtime claim holds, Knotty Jones becomes the first concrete demonstration of a game mechanic that is classically intractable but quantum-feasible, playable in real time on an early-FTQC.
PCG workloads that embed hard subroutines—fitness evaluation, constraint checking, or invariant computation—could offload those steps to quantum coprocessors, turning previously impossible content generation into a matter of circuit depth and qubit count.
The survey's resource ordering (qubits are most expensive, then circuit depth, then samples, then classical pre/post-processing) gives game developers a practical checklist for choosing which PCG algorithms to port first.
Quantum versions of cellular automata and grammars would not just speed up classical generation but produce genuinely different patterns, opening a new design space for generative art and level design.
Because the paper argues the same generate-and-reject pattern underpins many PCG methods, a quantum-computed fitness function could be swapped into existing pipelines more easily than a full quantum rewrite.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The one-minute runtime and logarithmic scaling are cited from a theoretical algorithm paper, not measured on hardware; the practical break-even crossing count—where a quantum machine beats a classical A100 after error-correction overhead—remains an open number the authors do not attempt to compute.
The Knotty Jones concept generalizes smoothly: any scoring function that is classically hard but has an efficient quantum algorithm (not just Jones polynomials) could become the basis of a 'quantum-native' puzzle, and the paper's resource ordering suggests which such functions are realistic on early hardware.
A testable intermediate step would be to implement Knotty Jones with a classical polynomial-time heuristic for small knots and reserve the quantum computation for the hardest opponent knots, measuring whether players can perceive any difference in generation quality—offering a near-term experiment that does not require a fault-tolerant machine.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: this is a readable vision paper that maps quantum algorithms onto procedural content generation, and it does that part honestly. But its signature example, the Knotty Jones game, rests on a runtime/scaling claim that the paper neither proves nor ties to its source in a way that supports the load. That is the one thing to know.

What the paper does well: the survey in Section II is level-headed. It says straight out that Grover gives only a quadratic speedup that overheads may swallow, that QAOA has no proven advantage, and that end-to-end complexity must include data encoding and decoding. The game design in Section III.B is genuinely clever: using Jones polynomial equality instead of knot equivalence sidesteps a hard equivalence check, and post-selecting opponents by their polynomial is a neat way to keep generation classical. None of that should be dismissed.

The soft spot is the feasibility statement for the game. Section III.B says the quantum algorithm runs in about one minute and “remains similar for much larger knots due to the QA’s logarithmic scaling.” No resource estimate is given: no qubit counts, T-gate counts, error-correction overhead, or data encoding cost. The paper’s own Section II.B says “any algorithm that is proposed must eventually be analyzed in the context of the full pipeline” and says that is not done in this paper. Then a few pages later the paper makes an end-to-end runtime claim as if it were established. That is an internal tension, and the claim is load-bearing for the game’s premise.

I also worry about the logarithmic scaling assertion. Jones polynomial evaluation at a root of unity is BQP-complete, and standard algorithms scale polynomially with the number of crossings. The cited Ref. [16] may indeed contain a worked end-to-end resource estimate, but the paper does not show the crossing-number dependence here. If the logarithmic scaling is only in precision, then “remains similar for much larger knots” is simply not supported. The authors elsewhere hedge appropriately; this one sentence does not.

The citation pattern is fine; the load-bearing reference is independent of the authors’ own work, and self-citation is not the issue here.

Who gets value: readers curious about quantum algorithms for games will enjoy the taxonomy and the Knotty Jones idea as a thought experiment. The paper is not a result paper, so I would not cite it for the runtime claim. It deserves a serious referee, though, because the vision itself is reasonable and the mapping is useful. My recommendation: send it out, and tell the authors to either substantiate the one-minute/log-scaling claim with a concrete reference to Ref. [16]’s resource sections or reframe it as speculation consistent with their own Section II.B.

Referee Report

2 major / 5 minor

Summary. This vision paper argues that fault-tolerant quantum computers (FTQCs) could soon be practically used in game development, and identifies procedural content generation (PCG) as a promising area. It surveys a selection of classical PCG approaches (search, constraint satisfaction, evolutionary algorithms, grammars, automata), pairs each with one or more quantum algorithms, and discusses resource considerations such as end-to-end complexity. The paper culminates in a hypothetical game, 'Knotty Jones', which would use a recent quantum algorithm for computing the Jones polynomial (Ref. [16]) to evaluate knot invariants during live gameplay. The authors claim that this algorithm runs in about one minute on a superconducting QC and scales logarithmically with knot size, making classically intractable knot evaluation possible in real time.

Significance. If the runtime and scaling claims for the Jones-polynomial algorithm are substantiated, the paper would present a concrete, game-embedded application of early fault-tolerant quantum computing with a substantial advantage over classical methods. This would be a novel and timely contribution to both the quantum-algorithms and PCG communities. The paper's strengths include its explicit articulation of end-to-end complexity as a central concern, its honest hedging about QAOA and quantum machine learning, and its correct observation that the generative part of the game (random Reidemeister moves and link inversions) does not itself require quantum computation. The central feasibility claim for Knotty Jones, however, rests on an unsupported runtime/scaling assertion about Ref. [16] that is in tension with the paper's own stated standards in §II.B. With that claim appropriately revised or supported, the paper would be a useful vision piece.

major comments (2)

[III.B (Knotty Jones), paragraph beginning 'Knotty Jones exploits a QA...'] The statement 'The QA running on a superconducting QC takes ≈ 1 minute, but this remains the similar for much larger knots due to the QA's logarithmic scaling' is presented as a fact, yet no supporting evidence or resource estimate is given. The paper does not cite a specific section, table, or figure in Ref. [16] that establishes this runtime, nor does it discuss qubit counts, T-gate counts, error-correction overheads, data-encoding costs, or output-decoding costs. This is particularly problematic because §II.B explicitly states that 'any algorithm that is proposed must eventually be analyzed in the context of the full pipeline of the PCG task. This is not something that can be done in this paper.' The runtime/scaling assumption is load-bearing for the game's claim of live, classically intractable knot evaluation. Please either provide the underlying resource estimate with a citation, o
[III.B, same paragraph] The claim of 'logarithmic scaling' is ambiguous: is the scaling logarithmic in the number of crossings, in the desired precision, or in both? Standard quantum algorithms for the Jones polynomial (e.g., Aharonov-Jones-Landau) scale polynomially in the crossing number, and BQP-completeness does not imply logarithmic crossing-number scaling. If Ref. [16] only provides logarithmic scaling in precision, then the sentence 'this remains the similar for much larger knots' is misleading. Please specify the precise scaling variable and provide a theorem or numerical evidence from Ref. [16] supporting the claim. If log scaling in crossing number is not established, the game's advantage at large knot sizes needs to be re-derived rather than asserted.

minor comments (5)

[Throughout] 'Reidermeister' is consistently misspelled; it should be 'Reidemeister' (e.g., Fig. 2, §III.B, Fig. 3 caption).
[I. Introduction, first paragraph] 'existance' should be 'existence'; also 'intractable into existance' should be reworded, e.g., 'bring games that are currently computationally intractable into existence'.
[III.B] 'For scale, an A100 is memory limited to ≈ 1500 crossings in ≈ 5 minutes' is an unsupported numerical claim with no citation or methodology. Please provide a reference or remove the specific numbers.
[III.B, footnote 1] 'Unrigorously defined' should be 'loosely defined' or 'informally defined'.
[Fig. 2 caption] The sentence 'Reidermeister moves do not change invariants of the knot, that is to say, they cannot untangle a knot beyond a certain number of a knot's inherent irreducible crossings' is confusing and should be rephrased; e.g., 'Reidemeister moves do not change the knot type, so they cannot reduce the number of crossings below the minimal crossing number of the knot.'

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the Knotty Jones proposal depends on an independent end-to-end Jones-polynomial algorithm, not on the authors' own results.

full rationale

The paper is a vision paper that proposes using known quantum algorithms for procedural content generation. Its central game, Knotty Jones, relies on the Jones-polynomial quantum algorithm of Ref. [16] (Laakkonen et al.), which is an independent, external work. The authors' own prior publications ([8], [9], [10], [23]) are cited for background context—defining quantum games, earlier procedural-generation ideas, map generation, and quantum natural-language generation—but none of these self-citations carries the load of the main feasibility claim. The runtime and scaling statement in Section III.B ('The QA running on a superconducting QC takes ≈ 1 minute, but this remains the similar for much larger knots due to the QA's logarithmic scaling') is asserted rather than derived, and it is in tension with Section II.B, which explicitly disclaims end-to-end analysis ('This is not something that can be done in this paper'). However, an unsupported or potentially over-optimistic runtime claim is a correctness/support concern, not a circularity: the claim is not obtained by fitting a parameter to the same data or by defining the output in terms of the input. No equation or definition in the paper makes the proposal equivalent to its inputs. The self-citations are not load-bearing, and the central algorithm is independent, so the circularity score is 0.

Assumptions & free parameters 0 free parameters · 3 assumptions · 0 invented entities

The paper's central proposal depends on unverified performance assumptions about future fault-tolerant hardware and on the correctness of cited quantum algorithms. No free parameters are fitted because the paper contains no measurements.

assumptions (3)

domain assumption Fault-tolerant quantum computers will be feasible in the next 5 to 10 years.
Stated in the abstract and introduction as the paper's premise ('making exploiting the advantages of fault-tolerant quantum computers feasible in the next 5 to 10 years').
domain assumption The Jones polynomial quantum algorithm of [16] has end-to-end logarithmic scaling in the crossing number and runs in about one minute on superconducting hardware.
Taken from [16]; the feasibility of Knotty Jones depends on this. See Section III.B.
domain assumption Computing the Jones polynomial is #P-hard and classically expensive, so the quantum algorithm provides a genuine advantage.
Standard complexity result cited from [16]. See Section III.B.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Procedural Generation and Games at the Dawn of Fault Tolerant Quantum Computing." pith.science (2026). https://pith.science/paper/LOXKKSS5

@misc{pith2026250809683,
  author       = {Pith},
  title        = {Pith review of: Procedural Generation and Games at the Dawn of Fault Tolerant Quantum Computing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/LOXKKSS5}},
  note         = {Machine review of arXiv:2508.09683}
}

read the original abstract

Quantum computers have long been more of a toy for researchers than a tool for solving complex problems. However, recent advances in the field make exploiting the advantages of fault-tolerant quantum computers feasible in the next 5 to 10 years. It is now time to begin imagining how such devices could be used in practice for game development and deployment. In this work we identify procedural content generation as a very promising area of application and exploration. We examine a selection of algorithmic approaches used in classical procedural content generation and propose promising quantum algorithms that could provide an alternative approach or a computational advantage. We then end with a hypothetical game that exploits a recent quantum algorithm for computing the Jones polynomial exponentially faster than classical computers could.

Figures

Figures reproduced from arXiv: 2508.09683 by the authors.

**Figure 3.** Although at lower knot complexities,1 most knots with the same JP are equivalent: there is a sequence of Reidermeister moves that transform between two equivalent knots. As the complexity of the knots increases, there are examples of knots that have the same JP but are not equivalent, such as the Conway knot and the Kinoshita–Terasaka knot. Here is where the game becomes more non-trivial and the advantage of a 1Unri… view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

37 extracted references · 24 canonical work pages

[16]

Laakkonen, E

T. Laakkonen, E. Rinaldi, C. N. Self, et al. , Less Quantum, More Advantage: An End-to-End Quantum Algorithm for the Jones Polynomial , Mar. 2025. DOI: 10 . 48550 / arXiv . 2503 . 05625. arXiv: 2503 . 05625 [quant-ph]

work page 2025
[1]

Aasen, M

D. Aasen, M. Aghaee, Z. Alam, et al., Roadmap to fault tolerant quantum computation using topological qubit arrays, Apr. 2025. DOI: 10.48550/arXiv.2502.12252. arXiv: 2502.12252 [quant-ph]

arXiv doi:10.48550/arxiv.2502.12252 2025
[2]

M. C. Toy, K. C. R. C. Arnold, and G. Wichman, Rogue, A.I. Design, 1980

work page 1980
[3]

Bouma and J

H. Bouma and J. Lefay, The Elder Scrolls II: Dagger- fall, Bethesda Softworks, 1996

work page 1996
[4]

Compressing and Comparing the Generative Spaces of Procedural Con- tent Generators,

O. Withington and L. Tokarchuk, “Compressing and Comparing the Generative Spaces of Procedural Con- tent Generators,” in 2022 IEEE Conference on Games (CoG), Aug. 2022, pp. 143–150. DOI: 10 . 1109 / CoG51982.2022.9893615

arXiv 2022
[5]

Quandoom -- DOOM as a quantum circuit

L. Mortimer, Quandoom – DOOM as a quantum circuit, Dec. 2024. DOI: 10.48550/arXiv.2412.12162. arXiv: 2412.12162 [physics]

work page Pith review arXiv doi:10.48550/arxiv.2412.12162 2024
[6]

M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information: 10th Anniversary Edition , https://www.cambridge.org/highereducation/books/quantum- computation-and-quantum- information/01E10196D0A682A6AEFFEA52D53BE9AE, Dec. 2010. DOI: 10.1017/CBO9780511976667

doi:10.1017/cbo9780511976667 2010
[7]

Quan- tum Algorithm Implementations for Beginners,

A. J, A. Adedoyin, J. Ambrosiano, et al. , “Quan- tum Algorithm Implementations for Beginners,” ACM Transactions on Quantum Computing , vol. 3, no. 4, pp. 1–92, Dec. 2022, ISSN : 2643-6809, 2643-6817. DOI: 10.1145/3517340. arXiv: 1804.03719 [cs]

arXiv 2022

Show all 37 references

[8]

Defining quantum games,

L. Piispanen, M. Pfaffhauser, J. Wootton, J. Togelius, and A. Kultima, “Defining quantum games,” EPJ Quan- tum Technology, vol. 12, no. 1, pp. 1–27, Dec. 2025, ISSN : 2196-0763. DOI: 10 . 1140 / epjqt / s40507 - 025 - 00308-7

2025
[9]

Procedural generation using quantum computation,

J. R. Wootton, “Procedural generation using quantum computation,” in Proceedings of the 15th International Conference on the Foundations of Digital Games , ser. FDG ’20, New York, NY , USA: Association for Computing Machinery, Sep. 2020, pp. 1–8, ISBN : 978- 1-4503-8807-8. DOI...

2020
[10]

A quantum procedure for map gen- eration,

J. R. Wootton, “A quantum procedure for map gen- eration,” in 2020 IEEE Conference on Games (CoG) , Aug. 2020, pp. 73–80. DOI: 10.1109/CoG47356.2020. 9231571

2020
[11]

Model Synthesis: A Gen- eral Procedural Modeling Algorithm,

P. Merrell and D. Manocha, “Model Synthesis: A Gen- eral Procedural Modeling Algorithm,” IEEE Transac- tions on Visualization and Computer Graphics , vol. 17, no. 6, pp. 715–728, Jun. 2011, ISSN : 1941-0506. DOI: 10.1109/TVCG.2010.112

2011 doi
[12]

Towards Wave Function Collapse using Optimization with Quantum Algorithms,

Z. Zhang, S. Cheng, K. Xiao, P. Gupta, and S. Ruda, “Towards Wave Function Collapse using Optimization with Quantum Algorithms,” in SIGGRAPH Asia 2024 Technical Communications , ser. SA ’24, New York, NY , USA: Association for Computing Machinery, Nov. 2024, pp. 1–4, ISBN : 97...

2024
[13]

Quantum Wave Function Collapse for Pro- cedural Content Generation,

R. Heese, “Quantum Wave Function Collapse for Pro- cedural Content Generation,” IEEE Computer Graphics and Applications, vol. 44, no. 5, pp. 54–66, Sep. 2024, ISSN : 1558-1756. DOI: 10.1109/MCG.2024.3447775

2024
[14]

WaveFunctionCollapse is constraint solving in the wild,

I. Karth and A. M. Smith, “WaveFunctionCollapse is constraint solving in the wild,” in Proceedings of the 12th International Conference on the Foundations of Digital Games, ser. FDG ’17, New York, NY , USA: As- sociation for Computing Machinery, Aug. 2017, pp. 1– 10, ISBN : 97...

2017 doi
[15]

Benchmarking quantum computers,

T. Proctor, K. Young, A. D. Baczewski, and R. Blume- Kohout, “Benchmarking quantum computers,” Nature Reviews Physics, vol. 7, no. 2, pp. 105–118, Feb. 2025, ISSN : 2522-5820. DOI: 10.1038/s42254-024-00796-z

2025 doi
[17]

Why Oatmeal is Cheap: Kol- mogorov Complexity and Procedural Generation,

Y . Rabii and M. Cook, “Why Oatmeal is Cheap: Kol- mogorov Complexity and Procedural Generation,” in Proceedings of the 18th International Conference on the Foundations of Digital Games , Apr. 2023, pp. 1–7. DOI: 10 . 1145 / 3582437 . 3582484. arXiv: 2305 . 02131 [cs]

2023
[18]

Pro- cedural Content Generation: Goals, Challenges and Ac- tionable Steps,

J. Togelius, A. J. Champandard, P. L. Lanzi, et al., “Pro- cedural Content Generation: Goals, Challenges and Ac- tionable Steps,” in Artificial and Computational Intelli- gence in Games, ser. Dagstuhl Follow-Ups, S. M. Lucas, M. Mateas, M. Preuss, P. Spronck, and J. Togelius, ...

2013 doi
[19]

Con- ditions for a quadratic quantum speedup in nonlinear transforms with applications to energy contract pric- ing,

G. Agliardi, C. O’Meara, K. Yogaraj, et al. , “Con- ditions for a quadratic quantum speedup in nonlinear transforms with applications to energy contract pric- ing,” Quantum Science and Technology , vol. 10, no. 2, p. 025 005, Jan. 2025, ISSN : 2058-9565. DOI: 10.1088/ 2058-9565/ada08c

2025
[20]

A. M. Dalzell, S. McArdle, M. Berta, et al., Quantum algorithms: A survey of applications and end-to-end complexities, Oct. 2023. DOI: 10 . 48550 / arXiv. 2310 . 03011. arXiv: 2310.03011

2023 doi arXiv
[21]

Guzdial, S

M. Guzdial, S. Snodgrass, and A. J. Summerville, Procedural Content Generation via Machine Learning: An Overview (Synthesis Lectures on Games and Com- putational Intelligence). Cham: Springer International Publishing, 2022, ISBN : 978-3-031-16718-8 978-3-031- 16719-5. DOI: 10....

2022 doi
[22]

Better than clas- sical? The subtle art of benchmarking quantum machine learning models,

J. Bowles, S. Ahmed, and M. Schuld, “Better than clas- sical? The subtle art of benchmarking quantum machine learning models,” arXiv preprint arXiv:2403.07059 ,

arXiv
[23]

Karamlou, M

A. Karamlou, M. Pfaffhauser, and J. Wootton, Quantum Natural Language Generation on Near-Term Devices , Nov. 2022. DOI: 10.48550/arXiv.2211.00727. arXiv: 2211.00727 [quant-ph]

2022 doi arXiv
[24]

Answer Set Programming for Procedural Content Generation: A Design Space Approach,

A. M. Smith and M. Mateas, “Answer Set Programming for Procedural Content Generation: A Design Space Approach,” IEEE Transactions on Computational In- telligence and AI in Games , vol. 3, no. 3, pp. 187–200, Sep. 2011, ISSN : 1943-0698. DOI: 10.1109/TCIAIG. 2011.2158545

2011
[25]

Machine learning for combinatorial optimization: A methodological tour d’horizon,

Y . Bengio, A. Lodi, and A. Prouvost, “Machine learning for combinatorial optimization: A methodological tour d’horizon,” European Journal of Operational Research, vol. 290, no. 2, pp. 405–421, Apr. 2021, ISSN : 0377-

2021
[26]

Practical Implementa- tion of a Quantum Backtracking Algorithm,

S. Martiel and M. Remaud, “Practical Implementa- tion of a Quantum Backtracking Algorithm,” in SOF- SEM 2020: Theory and Practice of Computer Science , A. Chatzigeorgiou, R. Dondi, H. Herodotou, et al. , Eds., Cham: Springer International Publishing, 2020, pp. 597–606, ISBN : ...

2020
[27]

S. P. Jordan, N. Shutty, M. Wootters, et al., Optimization by Decoded Quantum Interferometry , Aug. 2024. DOI: 10 . 48550 / arXiv . 2408 . 08292. arXiv: 2408 . 08292 [quant-ph]

2024
[28]

Search-based procedural content generation: A taxonomy and survey,

J. Togelius, G. N. Yannakakis, K. O. Stanley, and C. Browne, “Search-based procedural content generation: A taxonomy and survey,” IEEE Transactions on Com- putational Intelligence and AI in Games , vol. 3, no. 3, pp. 172–186, 2011

2011
[29]

Quantum vs clas- sical genetic algorithms: A numerical comparison shows faster convergence,

R. Ibarrondo, G. Gatti, and M. Sanz, “Quantum vs clas- sical genetic algorithms: A numerical comparison shows faster convergence,” in2022 IEEE Symposium Series on Computational Intelligence (SSCI), Dec. 2022, pp. 947–

2022
[30]

Shaker, J

N. Shaker, J. Togelius, and M. J. Nelson, Procedural Content Generation in Games (Computational Synthesis and Creative Systems). Cham: Springer International Publishing, 2016, ISBN : 978-3-319-42714-0 978-3-319- 42716-4. DOI: 10.1007/978-3-319-42716-4

2016 doi
[31]

Quantum automata and quantum grammars,

C. Moore and J. P. Crutchfield, “Quantum automata and quantum grammars,” Theoretical Computer Science , vol. 237, no. 1, pp. 275–306, Apr. 2000, ISSN : 0304-

2000
[32]

A comprehensive review of quantum machine learning: From NISQ to fault toler- ance,

Y . Wang and J. Liu, “A comprehensive review of quantum machine learning: From NISQ to fault toler- ance,” Reports on Progress in Physics , vol. 87, no. 11, p. 116 402, Oct. 2024, ISSN : 0034-4885. DOI: 10.1088/ 1361-6633/ad7f69

2024
[33]

Example-Based Procedural Modeling Using Graph Grammars,

P. Merrell, “Example-Based Procedural Modeling Using Graph Grammars,” ACM Trans. Graph., vol. 42, no. 4, 60:1–60:16, Jul. 2023, ISSN : 0730-0301. DOI: 10.1145/ 3592119

2023
[34]

Quantum algorithms for graph problems with cut queries,

T. Lee, M. Santha, and S. Zhang, “Quantum algorithms for graph problems with cut queries,” in Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algo- rithms (SODA), ser. Proceedings, Society for Industrial and Applied Mathematics, Jan. 2021, pp. 939–958. DOI: 10.1137/1.97...

2021 doi
[954]

DOI: 10.1109/SSCI51031.2022.10022159

2022
[2217]

DOI: 10.1016/j.ejor.2020.07.063

2020 doi
[3975]

DOI: 10.1016/S0304-3975(98)00191-1

doi

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.

[1] [16]

Laakkonen, E

T. Laakkonen, E. Rinaldi, C. N. Self, et al. , Less Quantum, More Advantage: An End-to-End Quantum Algorithm for the Jones Polynomial , Mar. 2025. DOI: 10 . 48550 / arXiv . 2503 . 05625. arXiv: 2503 . 05625 [quant-ph]

work page 2025

[2] [1]

Aasen, M

D. Aasen, M. Aghaee, Z. Alam, et al., Roadmap to fault tolerant quantum computation using topological qubit arrays, Apr. 2025. DOI: 10.48550/arXiv.2502.12252. arXiv: 2502.12252 [quant-ph]

arXiv doi:10.48550/arxiv.2502.12252 2025

[3] [2]

M. C. Toy, K. C. R. C. Arnold, and G. Wichman, Rogue, A.I. Design, 1980

work page 1980

[4] [3]

Bouma and J

H. Bouma and J. Lefay, The Elder Scrolls II: Dagger- fall, Bethesda Softworks, 1996

work page 1996

[5] [4]

Compressing and Comparing the Generative Spaces of Procedural Con- tent Generators,

O. Withington and L. Tokarchuk, “Compressing and Comparing the Generative Spaces of Procedural Con- tent Generators,” in 2022 IEEE Conference on Games (CoG), Aug. 2022, pp. 143–150. DOI: 10 . 1109 / CoG51982.2022.9893615

arXiv 2022

[6] [5]

Quandoom -- DOOM as a quantum circuit

L. Mortimer, Quandoom – DOOM as a quantum circuit, Dec. 2024. DOI: 10.48550/arXiv.2412.12162. arXiv: 2412.12162 [physics]

work page Pith review arXiv doi:10.48550/arxiv.2412.12162 2024

[7] [6]

M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information: 10th Anniversary Edition , https://www.cambridge.org/highereducation/books/quantum- computation-and-quantum- information/01E10196D0A682A6AEFFEA52D53BE9AE, Dec. 2010. DOI: 10.1017/CBO9780511976667

doi:10.1017/cbo9780511976667 2010

[8] [7]

Quan- tum Algorithm Implementations for Beginners,

A. J, A. Adedoyin, J. Ambrosiano, et al. , “Quan- tum Algorithm Implementations for Beginners,” ACM Transactions on Quantum Computing , vol. 3, no. 4, pp. 1–92, Dec. 2022, ISSN : 2643-6809, 2643-6817. DOI: 10.1145/3517340. arXiv: 1804.03719 [cs]

arXiv 2022