A Grover-Based Quantum Algorithm for Solving Perfect Mazes via Fitness-Guided Search

Michelle L. Wu

REVIEW 3 major objections 4 minor 16 references

A Grover-Based Quantum Algorithm for Solving Perfect Mazes via Fitness-Guided Search

T0 review · 3 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read This paper claims a complete quantum algorithm that solves perfect mazes through a reversible fitness-guided Grover search.

desk verdict The algorithm never uses the maze's walls, so it solves a wall-free grid; the paper's central claim is unsupported. read the letter →

arxiv 2507.21937 v2 pith:NWXLQAG5 submitted 2025-07-29 quant-ph cs.ETmath.QA

Michelle L. Wu This is my paper · ORCID

classification quant-phcs.ETmath.QA MSC 81P68

keywords quantumalgorithmGroversearchmazesolvingperfectamplitudeamplificationreversiblearithmeticadaptivecutofffitness-guided

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

This paper claims to give a full quantum pipeline that solves perfect mazes: it encodes every length-$n$ direction string in superposition, simulates each string to an endpoint in reversible arithmetic, scores the endpoint by squared Euclidean distance to the goal, and uses a Grover-compatible oracle to amplify the highest-scoring strings. The strongest stated result is that an adaptive cutoff, raised monotonically whenever a better fitness is observed, converges to an optimal path within a bounded number of rounds and with success probability at least $1-\varepsilon$. If the construction is correct, maze solving becomes a structured Grover search with per-iteration circuit depth $O(n\log m)$ and qubit count $O(n\log m)$, and the same fitness-oracle template extends to navigation over tree-like or acyclic graphs. A reader should care because this is an end-to-end specification—encoding, oracle, amplification, convergence—for a search problem with an unknown number of marked states.

What carries the argument

The carrying mechanism is the two-dimensional Grover subspace spanned by the normalized marked state $|\psi_T\rangle$ and unmarked state $|\psi_\perp\rangle$, together with the fitness oracle that defines the marked set. The initial state sits at angle $\theta=\arcsin\sqrt{k/N}$ from the unmarked subspace, so after $r$ iterations the success probability is $\sin^2((2r+1)\theta)$ and the optimal iteration count is $r^*\approx \pi/(4\theta)-1/2$. The fitness operator is built from direction-controlled coordinate updates, reversible subtraction and squaring, and uncomputation; the oracle is a reversible greater-than comparator followed by a controlled phase flip. The adaptive cutoff is the third piece: it converts an unknown number of marked states into a shrinking sequence of Grover problems whose final marked set contains only globally optimal strings.

What would settle it

Take a 2x2 perfect maze in which the only legal route from (0,0) to (1,1) is S,E, with a wall blocking every other interior crossing; implement the path-simulation and oracle exactly as specified (updates from Eq. 26 plus the Section XV bounds check) and list the fitness values of all 16 direction strings. If any wall-crossing string receives fitness above a cutoff that also holds for the true path, the circuit is amplifying wall-free grid strings, not maze paths—settling that the claimed maze-solving correctness depends on an added wall-consulting test.

Watch

Extended reading notes

Core claim

The central claim, in the paper's own terms, is that a perfect maze can be solved by a complete Grover-based algorithm rather than by classical backtracking. The paper defines a uniform superposition $|\Omega\rangle$ over all $4^n$ direction strings of length $n$, a reversible fitness operator $F:|x\rangle|0\rangle_f \mapsto |x\rangle|f(x)\rangle$ with $f(x)=C-((i-i_f)^2+(j-j_f)^2)$, and a phase oracle $O=C^{-1}ZC$ that flips the sign of strings whose fitness exceeds a cutoff. Grover iteration $G=DO$ rotates the state in the two-dimensional marked/unmarked subspace, and the monotonic cutoff rule $C_{t+1}=\max(C_t,f^*_t)$ is proved to reach the maximum fitness in at most $f_{\max}-C_1$ steps with high probability. The paper also presents formal arguments that the superposition is uniform over valid encodings, that both $F$ and $O$ are unitary, and that one round of search costs $O(n\log m)$ gates and qubits.

Load-bearing premise

The load-bearing premise is that a path is legal whenever its coordinates stay inside the grid; the maze's internal wall layout is never consulted in the simulation, so if walls block any boundary-respecting move, the algorithm can mark and amplify strings that walk through walls.

Editorial extensions

If this is right

A perfect maze can be compiled into a Clifford+T circuit whose depth per Grover round is $O(n\log m)$ and whose width is $O(n\log m)$, with $n$ path length and $m$ grid width.
The same oracle can accept a classical constant or a quantum register as the cutoff, so the adaptive scheme can run with thresholds supplied by another quantum subsystem.
The cutoff sequence reaches the maximum fitness in at most $f_{\max}-C_1\le 2m$ rounds; once there, the optimal strings are permanently marked and remain amplifiable.
Grover amplification provides the standard quadratic speedup: the number of oracle calls per round scales as $O(\sqrt{N/k})$ with $N=4^n$, whenever the marked set has size $k$.
The encoding-and-fitness pipeline transfers directly to navigation on tree-like or acyclic graphs, since those can be represented by direction strings with a distance-based fitness function.

Reading between the lines

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

I read the validity condition in Section XV—staying inside the $m\times m$ bounds—as the intended hook for enforcing the maze's actual walls; as written, the simulation updates coordinates without consulting the wall layout, so a wall-aware legality test would need to be added to the oracle for the claimed 'perfect maze' result to hold.
A concrete extension would be to compile the circuit for a 2x2 or 3x3 maze with known internal walls and check whether the amplified distribution assigns high probability to wall-crossing strings; that experiment separates the endpoint-optimality claim from true maze-path validity.
Because the number and identity of marked states is unknown, the practical speedup of the adaptive strategy depends on how quickly observed fitness rises as the cutoff climbs; the paper proves convergence but does not model that random-walk behavior, which is the natural next analysis.
The direction-string representation treats the maze as a complete $4$-ary tree of walks; for a perfect maze the legal paths form a much smaller tree, so comparing this encoding with search over the actual spanning tree is a testable route to reducing $N$.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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

Colleague,

The short version: the paper's central claim is false. The algorithm never consults the maze's walls. Equation (26) updates the walker's coordinates unconditionally for each direction, and the validity check in Section XV only tests whether coordinates stay within the grid. So the fitness function and oracle are defined on a wall-free grid, not on the maze. A path that walks straight through an internal wall gets the same score as one that follows the actual corridor. The 2x2 example makes this concrete: both S,E and E,S reach (1,1) from (0,0), but a perfect maze may block one of them. The algorithm marks the illegal one.

The motivation is also off. Perfect mazes are trees; the unique path between start and goal is found by classical BFS in linear time. Claiming the problem is NP-complete and that Grover gives a speedup is backwards. Even if the algorithm worked as intended, searching over all 4^n direction strings with O(2^n) Grover iterations is exponentially worse than the classical baseline.

What is good: the paper is a clear, self-contained review of Grover's algorithm, reversible adders, and a greater-than comparator. The Grover geometry derivation is correct, and the circuit constructions are standard. If you want a refresher on how to wire Grover around an arithmetic oracle, this is readable. But there is no new primitive, no new theorem, and no code. The adaptive cutoff is just a running maximum; Theorem 3 is a tautology about a monotone integer sequence. Theorem 4 assumes you know k_t, the number of marked states, to set the iteration count—exactly the quantity you don't know.

The wall problem is not a minor gap. It is load-bearing. The definitions in Section II include a wall-aware transition function δ, but the implementation in Section IV replaces δ with unconditional coordinate updates. That is an internal contradiction between the formalism and the circuit. The proof of Theorem 2 establishes unitarity of arithmetic, not correctness of the fitness function.

Bottom line: this should be desk-rejected, not sent to referees. It does not solve the stated problem, and the error is visible at the level of Eq. (26). I would not cite it. It might be worth a skim as a cautionary example of checking whether the implemented circuit matches the problem definition, but I wouldn't spend a reading group session on it.

Referee Report

3 major / 4 minor

Summary. The paper proposes a Grover-based quantum algorithm for solving perfect mazes. It encodes all length-n direction strings as 2n-qubit states, simulates their motion from a start cell, computes a fitness value C - squared Euclidean distance to the goal, marks states with fitness above an adaptive cutoff, and iterates Grover amplification. The paper claims formal proofs of correctness, unitarity, and convergence, together with resource estimates. The central thesis is that this pipeline solves a perfect maze by amplifying high-fitness paths.

Significance. The Grover geometry portion (Sections VI–VII) is a correct re-derivation of standard amplitude-amplification facts, and the reversible arithmetic circuit sketches are based on recognized primitives. However, the algorithm as specified never consults the maze's wall layout: Eq. (26) updates coordinates unconditionally, and the validity check in Section XV only tests grid bounds. Fitness values, the oracle's marked set, and all subsequent success-probability statements are therefore computed on a wall-free grid, not on the perfect maze M defined by the transition function δ in Eq. (3). This is a load-bearing defect that invalidates the central claim. The adaptive-cutoff analysis is also unsupported: Theorem 4 requires knowledge of k_t, the number of marked states, and the oracle's strict inequality in Eq. (33) is inconsistent with Corollary 2's equality-based marking. The paper provides no machine-checked proofs or reproducible code; its solid content is a textbook-level account of Grover search.

major comments (3)

[IV, Eq. (26); XV] The fitness operator never checks maze walls. Eq. (26) defines unconditional coordinate updates (i-1, j+1, i+1, j-1), and Section XV's validity flag is defined as valid(x)=1 iff every intermediate cell lies in [0,m-1]^2, with no wall test. Consequently end(P), the distance in Eq. (24), and the oracle's marked set are determined by a wall-free grid, not by the perfect maze M. For example, in the paper's own 2x2 setting, the path S,E reaches (1,1) from (0,0), but a perfect maze may have a wall blocking one of those moves; the algorithm would mark the illegal path as optimal. Since the marked set is the input to the Grover success-probability analysis in Sections VI and VII, all correctness statements in the paper are about a different search problem than the one claimed.
[IX, Theorem 4; Eq. (83)] The proof requires choosing r_t so that (2r_t+1)θ_t ≈ π/2, where θ_t = arcsin(sqrt(k_t/N)) and k_t = |{x : f(x) > C_t}| is the number of marked states at threshold C_t. This requires knowing k_t, which is precisely the unknown quantity that Grover search is intended to find. No procedure for estimating or avoiding k_t is given, so the asserted per-round success probability P_t ≥ 1−δ is unjustified. Additionally, at C_t = fmax the strict inequality in Eq. (33) marks no states at all, so Corollary 2's statement that the oracle 'permanently marks all global optima' is false; the claimed final amplification step with k=1 is not achieved by the specified oracle.
[VIII, IX; Theorem 3 and Theorem 4] The convergence proof conflates the monotonicity of a classical cutoff sequence with the probabilistic behavior of quantum measurements. Theorem 3 shows only that if a sequence of observed fitness values with f_t* > C_t occurs, then the cutoff increases; it does not show that each Grover round produces such a value with any nontrivial probability. Before C_t reaches fmax, the marked set can be large, and without knowledge of k_t the algorithm has no way to ensure that the measured state has f(x) > C_t. The claimed halting within T ≤ 2m rounds with success probability at least 1−ε is therefore not established. The proof also assumes fmax ≤ 2m, which is inconsistent with Eq. (24), where C ≥ 2(m−1)^2 and fitness is C − distance, so fmax can be much larger than 2m.

minor comments (4)

[Introduction and Section II] The statement that perfect mazes (loop-free, acyclic grids) make the problem 'computationally intractable and NP-complete' is incorrect; finding a path in a tree is solvable in linear time by DFS or BFS. NP-completeness holds for general grid mazes with cycles, not for perfect mazes as defined here.
[VI and Eq. (83)] The search-space size N is written as '4n' in Section VI and Eq. (83), but the number of direction strings of length n is 4^n (as stated in Section II). Since the Grover angle θ depends on N, the notation should be corrected to 4^n throughout.
[IV and Appendix XII] The fitness register size is defined as r = ceil(log2 C) with C = 2^r ≥ 2(m−1)^2, but Appendix XII describes a '(log m)-qubit fitness output register' and the worked example uses C = 2m; these presentations should be reconciled.
[References] Reference [13] (Duchi et al., projections onto the l1-ball) is unrelated to the comparison or search circuits discussed in the paper and should be removed or replaced with a relevant reversible-comparator reference.

Circularity Check

2 steps flagged · score 6.0 of 10

The adaptive-cutoff convergence proof presumes knowledge of k_t, the very marked-state count the search is supposed to discover; the central convergence claim therefore reduces to an assumption of its own conclusion.

self definitional [Section IX, Theorem 4 proof, Eqs. (83)-(85)]
"Let θt be the angle defined by: sin2 θt = kt N , where kt = |{x : f (x) > Ct}|, N = 4n. (83) By Grover geometry, the success probability after rt rounds is: Pt = sin2((2rt + 1)θt). (84) If we choose rt such that (2rt + 1)θt ≈ π 2 , then Pt ≥ 1 − δ, where δ is small."

The proof selects the Grover iteration count rt from θt, and θt is defined through kt, the number of marked states above the current cutoff. The paper supplies no circuit or procedure to compute kt without already knowing all high-fitness paths; kt is exactly the information the search is meant to reveal. Consequently the bounded-time, high-probability convergence guarantee is conditional on knowledge of the target quantity. The proof additionally relies on updates occurring when new maxima are found, which presupposes the success of the search being proven. The convergence claim thus reduces to an assumption of its own conclusion.
other [Section VIII, Corollary 2; contrast with Section V, Eq. (33)]
"Corollary 2 (Persistence of Maximum Amplification). Once Ct = fmax, all optimal states x⋆ with f(x⋆) = fmax will be marked by the oracle in all subsequent iterations: f(x⋆) > Ct = fmax ⇒ False but f(x⋆) = Ct = fmax ⇒ phase flip occurs if f(x) ≥ Ct."

The oracle defined in Section V, Eqs. (32)-(33), flips the phase only when fx > cutoff. This corollary silently changes the marking predicate to f(x) ≥ Ct so that optimal states become marked when the cutoff reaches fmax. Theorem 4 then relies on the corollary to assert that the oracle marks only optimal solutions. The persistence of maximum amplification is therefore not derived from the constructed comparator; it is made true by redefining the oracle acceptance condition, inserting the desired conclusion into the premise of the convergence theorem.

full rationale

Most of the paper independently re-derives textbook Grover amplitude-amplification geometry (Sections VI-VII) and constructs reversible comparators and arithmetic from standard external references; no self-citation chain is load-bearing, so the self-citation patterns do not apply. The wall-independence defect (Eq. (26) updates coordinates unconditionally and Section XV validates only grid bounds, while Eq. (3) promised a wall-aware transition function) is a correctness/fidelity mismatch rather than a circularity and is therefore not scored here. The genuine circularity is concentrated in the adaptive-cutoff convergence proof: the iteration count rt is chosen from θt, and θt is defined by kt, the number of states above the cutoff, which is the very quantity the search must discover. This makes the central bounded-time convergence guarantee conditional on knowing the answer; the adaptive strategy is not adaptive with respect to unknown kt. There is also a redefinition of the oracle predicate from strict > to ≥ in Corollary 2, which the convergence theorem uses as a premise. Because the Grover components are independent but the paper's novel convergence claim reduces to an assumption of its own conclusion, the circularity score is 6.

Assumptions & free parameters 2 free parameters · 5 assumptions · 0 invented entities

No new physical or mathematical entities are postulated. The fitness-guided oracle is a circuit construction built from standard operations, not a new particle, mediator, force, or dimension. The load-bearing assumptions are the wall-free grid encoding and the unknown-k availability.

free parameters (2)

path length n
The search space size is 4^n; the paper says n may be set heuristically or adapted, but if n < length of the true path the solution is excluded. The algorithm's correctness depends on this hand-chosen parameter.
initial cutoff C1
The adaptive scheme starts from an arbitrary integer C1; the convergence time bound fmax - C1 depends on it, and no guidance is given for choosing it.

assumptions (5)

domain assumption A perfect maze is a tree over the grid, so there is exactly one simple path between any two reachable cells.
Used in Section II to justify the loop-free condition and the spanning-tree structure. This is the paper's own definition, but the classical pathfinding problem on a tree is solvable in linear time, undercutting the stated NP-completeness.
ad hoc to paper Squared Euclidean distance to the goal is a useful fitness signal for maze pathfinding.
The fitness function (Eq. 24) scores paths by endpoint distance only; no maze wall data enters. The paper provides no argument that this heuristic guides a quantum search to a valid maze path.
ad hoc to paper The number of marked states k_t is available to set the optimal Grover iteration count r_t.
Theorem 4 requires choosing r_t with (2r_t+1)theta_t approximately pi/2, but theta_t depends on k_t = |{x: f(x) > cutoff}|, which the algorithm never computes. The paper does not show how to set r_t without knowing k_t.
domain assumption Noiseless gates and perfect measurements.
Stated in Section X as an idealized assumption.
standard math Reversible arithmetic primitives (Cuccaro adder, Toffoli multipliers) are unitary.
Invoked in Section IV and Appendix XII with cites [1,2,5,6].

how reviews work

0 comments

Cite this review

Pith. "Pith review of A Grover-Based Quantum Algorithm for Solving Perfect Mazes via Fitness-Guided Search." pith.science (2026). https://pith.science/paper/NWXLQAG5

@misc{pith2026250721937,
  author       = {Pith},
  title        = {Pith review of: A Grover-Based Quantum Algorithm for Solving Perfect Mazes via Fitness-Guided Search},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NWXLQAG5}},
  note         = {Machine review of arXiv:2507.21937}
}

read the original abstract

We present a quantum algorithm for solving perfect mazes by casting the pathfinding task as a structured search problem. Building on Grover's amplitude amplification, the algorithm encodes all candidate paths in superposition and evaluates their proximity to the goal using a reversible fitness operator based on quantum arithmetic. A Grover-compatible oracle marks high-fitness states, and an adaptive cutoff strategy refines the search iteratively. We provide formal definitions, unitary constructions, and convergence guarantees, along with a resource analysis showing efficient scaling with maze size and path length. The framework serves as a foundation for quantum-hybrid pathfinding and planning. The full algorithmic pipeline is specified from encoding to amplification, including oracle design and fitness evaluation. The approach is readily extensible to other search domains, including navigation over tree-like or acyclic graphs.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

16 extracted references · 12 canonical work pages

[1]

A new quantum ripple-carry addition circuit,

S. A. Cuccaro, T. G. Draper, S. A. Kutin, and D. P. Moulton, “A new quantum ripple-carry addition circuit,” Los Alamos National Lab (LANL), arXiv preprint arXiv:quant-ph/0410184, 2004. [Online]. Available: https://arxiv.org/abs/quant-ph/0410184

arXiv 2004
[2]

Addition on a quantum computer,

T. G. Draper, “Addition on a quantum computer,” arXiv preprint quant- ph/0008033, 2000

arXiv 2000
[3]

A fast quantum mechanical algorithm for database search,

L. K. Grover, “A fast quantum mechanical algorithm for database search,” Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC) , pp. 212–219, 1996

work page 1996
[4]

M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information. Cambridge University Press, 2010

2010
[5]

Elementary gates for quantum computation,

A. Barenco, C. H. Bennett, R. Cleve, D. P. DiVincenzo, N. Margolus, P. Shor, T. Sleator, J. A. Smolin, and H. Weinfurter, “Elementary gates for quantum computation,” Physical Review A , vol. 52, no. 5, p. 3457, 1995

work page 1995
[6]

Time/space trade-offs for reversible computation,

C. H. Bennett, “Time/space trade-offs for reversible computation,” in SIAM Journal on Computing , vol. 18, no. 4, 1989, pp. 766–776

work page 1989
[7]

Quantum- inspired maze-solving: A hybrid quantum-classical path search method,

S. Cuomo, G. De Pietro, A. Forestiero, and G. Spezzano, “Quantum- inspired maze-solving: A hybrid quantum-classical path search method,” Entropy, vol. 24, no. 4, p. 482, 2022

work page 2022
[8]

The qiskit textbook: Learn quantum computation using qiskit,

Q. Community, “The qiskit textbook: Learn quantum computation using qiskit,” 2020, https://qiskit.org/textbook

work page 2020

Show all 16 references

[9]

An introduction to quantum machine learning,

M. Schuld, I. Sinayskiy, and F. Petruccione, “An introduction to quantum machine learning,” Contemporary Physics, vol. 56, no. 2, pp. 172–185, 2015

2015
[10]

Quantum circuit simplifi- cation and level compaction,

D. Maslov, D. M. Miller, and G. W. Dueck, “Quantum circuit simplifi- cation and level compaction,” in IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , vol. 27, no. 3. IEEE, 2008, pp. 436–444

2008
[11]

Qubit allocation and reordering in quantum circuits,

V . V . Shende, S. S. Bullock, and I. L. Markov, “Qubit allocation and reordering in quantum circuits,” International Workshop on Quantum Information and Computation , 2003

2003
[12]

Tight bounds on quan- tum searching,

M. Boyer, G. Brassard, P. Høyer, and A. Tapp, “Tight bounds on quan- tum searching,” Fortschritte der Physik: Progress of Physics , vol. 46, no. 4-5, pp. 493–505, 1998

1998
[13]

Efficient pro- jections onto the l1-ball for learning in high dimensions,

J. Duchi, S. Shalev-Shwartz, Y . Singer, and T. Chandra, “Efficient pro- jections onto the l1-ball for learning in high dimensions,” Proceedings of the 25th international conference on Machine learning , pp. 272–279, 2008

2008
[14]

A novel quantum circuit for testing integer comparison,

A. Younes, J. Miller, and J. Cadenas, “A novel quantum circuit for testing integer comparison,” Journal of Physics A: Mathematical and General , vol. 39, no. 42, p. 13219, 2006

2006
[15]

Efficient decom- position of quantum gates,

J. J. Vartiainen, M. M ¨ott¨onen, and M. M. Salomaa, “Efficient decom- position of quantum gates,” in Physical Review Letters, vol. 92, no. 17, 2004, p. 177902

2004
[16]

Grover algorithm with zero theoretical failure rate,

G. L. Long, “Grover algorithm with zero theoretical failure rate,” Physical Review A , vol. 64, no. 2, p. 022307, 2001

2001

Pith tools

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

[1] [1]

A new quantum ripple-carry addition circuit,

S. A. Cuccaro, T. G. Draper, S. A. Kutin, and D. P. Moulton, “A new quantum ripple-carry addition circuit,” Los Alamos National Lab (LANL), arXiv preprint arXiv:quant-ph/0410184, 2004. [Online]. Available: https://arxiv.org/abs/quant-ph/0410184

arXiv 2004

[2] [2]

Addition on a quantum computer,

T. G. Draper, “Addition on a quantum computer,” arXiv preprint quant- ph/0008033, 2000

arXiv 2000

[3] [3]

A fast quantum mechanical algorithm for database search,

L. K. Grover, “A fast quantum mechanical algorithm for database search,” Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC) , pp. 212–219, 1996

work page 1996

[4] [4]

M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information. Cambridge University Press, 2010

2010

[5] [5]

Elementary gates for quantum computation,

A. Barenco, C. H. Bennett, R. Cleve, D. P. DiVincenzo, N. Margolus, P. Shor, T. Sleator, J. A. Smolin, and H. Weinfurter, “Elementary gates for quantum computation,” Physical Review A , vol. 52, no. 5, p. 3457, 1995

work page 1995

[6] [6]

Time/space trade-offs for reversible computation,

C. H. Bennett, “Time/space trade-offs for reversible computation,” in SIAM Journal on Computing , vol. 18, no. 4, 1989, pp. 766–776

work page 1989

[7] [7]

Quantum- inspired maze-solving: A hybrid quantum-classical path search method,

S. Cuomo, G. De Pietro, A. Forestiero, and G. Spezzano, “Quantum- inspired maze-solving: A hybrid quantum-classical path search method,” Entropy, vol. 24, no. 4, p. 482, 2022

work page 2022

[8] [8]

The qiskit textbook: Learn quantum computation using qiskit,

Q. Community, “The qiskit textbook: Learn quantum computation using qiskit,” 2020, https://qiskit.org/textbook

work page 2020