Spells for Quantum Programmers:
Expressive High-Level Commands in Qutes

Classical computers have achieved extraordinary levels of performance and reliability, yet they remain fundamentally grounded in a mundane computational paradigm: every operation must be spelled out explicitly, step by step, and every algorithm is ultimately reduced to a long sequence of local instructions [22]. This model has shaped the way programmers think about computation for decades, encouraging a procedural mindset in which complex behaviour emerges only after carefully orchestrating many simple actions.

Quantum computing challenges this worldview. Quantum devices natively operate on superpositions, interference patterns, and entangled collections of states, enabling transformations that act globally on entire registers of qubits [5, 3]. From an algorithmic perspective, these machines behave less like refined classical engines and more like instruments capable of performing inherently non-local actions. In this sense, quantum computers resemble wizard machines: they can accomplish effects that would appear magical from a classical standpoint, such as evaluating many computational paths simultaneously or correlating distant pieces of information through entanglement [17, 25].

Despite this fundamental difference, most quantum programs are still written as if quantum computers were merely faster or more exotic versions of muggle ones. Contemporary quantum programming frameworks expose developers to low-level circuit descriptions, individual gate applications, and explicit qubit management [27]. As a result, programmers are often forced to reason locally, even when the underlying algorithm is global in nature. This mismatch between the conceptual structure of quantum algorithms and their concrete implementations leads to verbose code, obscured intent, and a steep barrier to experimentation [14, 21].

Magic, however, is not performed by raw power alone. Even the most powerful magical artefacts require a disciplined use of well-defined incantations. In other words, wizard machines demand a spellbook. In the context of quantum computing, such a spellbook takes the form of a programming language that provides high-level abstractions aligned with the natural operations of quantum systems [7]. Rather than manipulating individual gates, programmers should be able to invoke expressive commands that encapsulate complex quantum behaviour behind a clear and compact syntax.

In recent years, considerable effort has been devoted to the design of quantum programming languages, with the goal of raising the level of abstraction and making quantum software development more accessible [21]. While these languages often describe themselves as high-level, many of them remain closely tied to circuit-centric models and gate-by-gate reasoning, largely reflecting the low-level programming style traditionally adopted by physicists [14]. As a consequence, programmers are still required to think in terms of individual qubits, explicit gate sequences, and manual data movement, even when working with algorithms whose structure is inherently global. This situation highlights the need to move quantum programming away from a hardware-driven, physicist-oriented perspective and toward a more genuinely algorithmic and computer-scientific view of computation [7].

It is precisely in this gap between declared abstraction and actual programming practice that Qutes [10] is positioned.¹¹1Further information on Qutes, including documentation, examples, and source code, can be found at the official website https://qutes-lang.org/. Qutes is a high-level quantum programming language designed to move beyond circuit-oriented thinking and align programming constructs with algorithmic intuition. Instead of exposing programmers to low-level quantum operations, Qutes provides concise primitives that seamlessly integrate classical control and quantum computation, making quantum programs more readable and enjoyable to write. [11].

In this work, we fully embrace this perspective and present Qutes as a genuine spellcasting language for quantum programmers. Our focus is on one of the most pervasive yet systematically underserved aspects of quantum programming: the manipulation of quantum arrays. Arrays arise naturally in a wide spectrum of quantum algorithms, from search and optimisation to data reordering and sampling [17, 9], yet they remain notoriously awkward to handle when expressed at the level of individual qubits and gates [15, 21]. To address this gap, we introduce a small but expressive collection of array-oriented incantations, summarised in the spellbook of Table 1, which capture common global patterns of quantum computation in a compact and declarative form.

We show that enriching Qutes with these carefully designed array spells makes it possible to express non-trivial quantum algorithms in a way that is readable, compositional, and unexpectedly elegant. While the spells do not extend the computational power of quantum machines per se, they fundamentally reshape how programmers interact with it: global structure replaces local bookkeeping, intent replaces wiring, and parallelism emerges naturally from high-level descriptions. As a concrete and perhaps surprising side effect, composing these spells yields a fully quantum odd–even Bubble Sort whose compiled circuit, for an array of $n$ elements encoded on $d$ qubits each, has depth $\mathrm{\Theta }(nd)$ (linear in $n$ when $d=O(1)$) and size $\mathrm{\Theta }(n^{2}d)$. This result does not contradict known lower bounds [20], but it illustrates how high-level array abstractions can expose parallelism that is difficult to perceive at the circuit level, reinforcing our central message: better spells do not make machines more powerful, but they allow programmers to use their power far more effectively.

The remainder of the paper is organised as follows. Section 2 reviews the quantum computation model and the complexity measures adopted throughout the paper. Section 3 presents Qutes as a spellcasting language and illustrates its expressiveness through simple examples. Section 4 introduces three new array-oriented spells, i.e. global initialization, parallel comparison, and parallel and controlled transposition, together with their circuit-level realizations. In Section 5, these spells are composed into a highly parallel Bubble Sort, serving as a case study on expressiveness and depth/size trade-offs. Section 6 concludes with a broader discussion on abstraction and parallelism in quantum programming.

Quantum computation differs from classical computation not only in its physical realisation, but in the way information is represented and manipulated [5, 3]. Classical bits take definite values, whereas quantum information is encoded in qubits, whose states are unit vectors in a complex Hilbert space. A single qubit may exist in a superposition $|\psi ⟩=\alpha |0⟩+\beta |1⟩$, with ${|\alpha |}^2+{|\beta |}^2=1$, allowing a single computational object to encode multiple classical configurations at once.

When multiple qubits are combined, their joint state lives in the tensor product space ${({ℂ}^2)}^{\otimes n}$, whose dimension grows exponentially with the number of qubits [3]. A general state $|\mathrm{\Psi }⟩={\sum }_{x\in {\{0,1\}}^n}{\alpha }_x|x⟩$ encodes exponentially many basis configurations simultaneously. Unitary operators act globally on this space, transforming all components of the superposition in a single coherent step. This global action is often referred to as quantum parallelism [5, 25].

Entanglement further distinguishes quantum information from its classical counterpart. A state is entangled when it cannot be written as a tensor product of its subsystems, implying that the behaviour of individual qubits cannot be described independently [1]. Entangled registers therefore act as unified computational objects, whose properties arise from collective structure rather than from isolated components. In this sense, arrays of qubits naturally behave as indivisible, enchanted artefacts.

Measurement marks the interface between quantum and classical computation. Measuring a quantum register collapses its state to a single basis outcome, irreversibly destroying superposition and entanglement [23]. Algorithmically, measurement extracts classical information from a global quantum object, but only at the cost of discarding the richer structure that enabled quantum computation in the first place [23].

Throughout the paper we assume the standard circuit model with bounded fan-in gates and unit-cost single- and two-qubit operations [23]. Our constructions rely on a conventional gate set including Pauli-X and Hadamard gates for state preparation and superposition, CNOT and Toffoli gates for controlled and reversible logic, and SWAP and controlled-SWAP (Fredkin) gates for data movement and conditional transpositions (see Figure 1) [23]. More complex operations are obtained by composing these gates in structured patterns.

From an operational perspective, quantum computation exhibits two complementary forms of parallelism. At the circuit level, gates acting on disjoint sets of qubits can be executed simultaneously, making circuit depth a more faithful measure of execution time than gate count [23]. At a deeper level, superposition allows the same unitary transformation to be applied coherently to many basis states at once. These computational paths are not independently observable, but interfere through their amplitudes, enabling the extraction of global information through carefully designed algorithms [5, 17, 25].

To reason about the cost of quantum programs, we adopt the standard notion of circuit complexity [23]. A quantum circuit is characterised by its size, defined as the total number of elementary gates, and its depth, defined as the number of sequential layers of gates acting on disjoint qubits. While circuit size captures the overall resource consumption, circuit depth more accurately reflects the execution time in the circuit model, as gates within the same layer can be applied in parallel [23]. Throughout the paper, we therefore use circuit depth as the primary measure of time complexity, understood as the number of sequential layers of logical quantum gates assuming Toffoli and Fredkin operations as constant-depth primitives, while circuit size is used to quantify the total amount of required quantum hardware activity.

Despite this inherently global nature of quantum computation, most quantum programs are still expressed in a low-level, circuit-centric style, where arrays of qubits are treated as collections of individually addressed wires [21, 14]. This approach obscures the fact that quantum algorithms are, semantically, transformations over high-dimensional vector spaces [3]. Arrays therefore represent a crucial abstraction boundary: while their implementation relies on local gates, their natural manipulation is inherently collective.

Over the past years, a rich ecosystem of quantum programming languages and frameworks has emerged, each aiming to make quantum computation more accessible and expressive [18, 6, 4, 26, 16, 2]. From an abstract perspective, these languages provide programmers with a variety of magical instruments: gates, circuits, oracles, and control structures that enable interaction with quantum hardware. However, many of these tools resemble raw magical artefacts rather than refined spells: powerful, yet demanding careful low-level manipulation and a deep familiarity with the underlying mechanics.

Circuit-based frameworks such as Qiskit, Cirq, and OpenQASM expose quantum programs directly as circuits, offering precise and fine-grained control [18, 6, 4]. In these environments, every qubit, gate, and control dependency must be specified explicitly, and even simple algorithmic ideas quickly expand into long sequences of low-level operations. Programming in this style often feels like assembling a spell one rune at a time: exact and expressive for experts, but verbose and error-prone when reasoning at the algorithmic level, especially for operations that are inherently global.

Other quantum programming languages, including Q#, Quipper, and Silq, attempt to raise the level of abstraction by introducing classical control flow, functional constructs, or richer type systems [26, 16, 2]. Nevertheless, despite their declared high-level nature, many of these approaches remain closely tied to the circuit model. Their abstractions often leak gate-level details, forcing programmers to reason explicitly about ancilla management, reversibility, and data movement even when manipulating structured quantum data.

At the current stage of the field, much of what is described as “high-level” quantum programming is high-level primarily from a physicist’s perspective. From a computer scientist’s point of view, these abstractions often remain uncomfortably close to the circuit description, exposing details that would traditionally belong to a low-level implementation layer. This reflects the historical roots of quantum computing rather than a limitation of the models themselves, and highlights the need for a language that is indecently computer-scientific. What is missing is not computational power, but a spellbook: a language offering concise incantations that directly capture common quantum algorithmic patterns, allowing programmers to operate on enchanted objects rather than on individual components.

Against this background, Qutes [11, 10] takes a deliberately different approach. Rather than exposing quantum computation through circuits or gate sequences, Qutes is designed as a high-level, domain-specific language whose goal is to align programming constructs with the way quantum algorithms are conceived. In the magical metaphor adopted throughout this paper, Qutes plays the role of a spellbook: a curated collection of expressive incantations that allow programmers to invoke complex quantum behaviour without assembling it manually from low-level components, making programming in Qutes fun by design.

At its core, Qutes treats quantum data as first-class objects. Quantum variables, registers, and arrays are manipulated through concise language primitives that abstract away circuit wiring, gate placement, and register bookkeeping. Classical and quantum computation coexist naturally: classical control structures such as conditionals and loops interact seamlessly with quantum data, while implicit casting and measurement rules govern transitions between the quantum and classical realms. We do not delve here into the formal definition of Qutes types and core structures, and refer the interested reader to [10] for a detailed presentation.

A defining feature of Qutes is its emphasis on expressiveness over verbosity. Common quantum patterns, such as state preparation, conditional execution, or structured iteration over quantum data, are captured by compact constructs whose semantics correspond to well-defined quantum operations. While the underlying execution model remains fully unitary and compatible with standard circuit semantics, these details are intentionally hidden behind higher-level abstractions. Qutes programs are compiled into executable quantum circuits, ensuring compatibility with existing simulators and hardware backends, while freeing programmers from circuit-centric reasoning during development.

To give a concrete taste of Qutes’ expressive power, we present two simple examples in which non-trivial quantum behaviour emerges from compact, spell-like commands.

Taken together, these examples illustrate a recurring pattern. While circuit-level descriptions faithfully capture the mechanics of quantum computation, they often obscure the structure of the algorithm itself. Qutes allows programmers to express quantum routines at the level of conceptual operations, delegating low-level details to the compiler and runtime. This expressive gap motivates the introduction of the array-oriented spells presented in the remainder of the paper, which show how a small set of high-level constructs suffices to encode non-trivial quantum algorithms.

Quantum arrays play a central role in quantum algorithm design, providing a natural abstraction for structured data and intermediate computational states. While arrays are ubiquitous and conceptually simple in classical computation, their quantum counterparts introduce additional challenges related to reversibility, entanglement, and coherent data access [15, 19]. These difficulties arise from the mismatch between the global nature of quantum states and the inherently local character of circuit-level descriptions.

Existing quantum programming languages and frameworks offer mechanisms to manipulate quantum registers that resemble arrays [18, 6, 4], but these mechanisms often expose low-level circuit details. As a result, even simple array transformations tend to unfold into verbose gate-level constructions, obscuring the underlying algorithmic intent.

Qutes adopts a different approach by treating quantum arrays as first-class enchanted objects. Programmers interact with arrays through high-level spells that describe global transformations, while the circuit-level realization is deliberately hidden [24, 13]. This shift from procedural qubit manipulation to declarative, array-oriented operations allows quantum programs to be expressed in terms of semantic intent rather than implementation detail.

In Qutes, quantum arrays are provided as a native language abstraction and can be instantiated directly through a dedicated construct. This allows programmers to work with structured quantum collections from the outset, much like declaring an array in a classical language, while avoiding explicit low-level register management.

The first fundamental operation concerns the initialization of a quantum array from a finite sequence of elements. In a classical, muggle-oriented setting, this task naturally unfolds as a linear-time procedure that assigns values to array cells one by one. In Qutes, by contrast, the initialization of an array from a prescribed sequence is expressed as a single high-level command, semantically executed in constant time. From a magical perspective, this corresponds to conjuring an enchanted artefact directly in its intended configuration, rather than assembling it piece by piece.

A second fundamental operation is access to a specific array position. Classically, reading the content of the cell at position $i$ is treated as a primitive whose cost is hidden by the memory abstraction. In the quantum setting, however, data access must respect reversibility and unitarity constraints, making the notion of random access considerably more delicate [15]. Unlike QRAM-based models, the access mechanism adopted in Qutes does not assume specialised hardware support, but is realised entirely within the standard circuit model.

In Qutes, access to the content stored at position $i$ is realised through a simple two-step spell. First, the array is cyclically rotated so that the element originally at position $i$ is brought to the front. Then, the content of the first cell is transferred into a dedicated quantum variable, without exposing the rearrangement of the remaining elements. This decomposition mirrors the programmer’s intent while preserving a clean and uniform abstraction.

To appreciate the expressive gap bridged by Qutes, it is instructive to briefly step back into the muggle world of circuit-based quantum computation, where the same operations must be realised explicitly at the level of gates and wires. Figure 2 illustrates a circuit for the initialisation of a small quantum array and a parametric access to its elements.

The array consists of four logical elements, each encoded using two qubits²²2The number of qubits allocated to values of type quint is a compile-time parameter that is fixed prior to execution, allowing the bit-width of quantum integers to be chosen independently of the program logic., for a total of eight data qubits arranged in the register $|v⟩$. The initialization phase (Example 3) appears at the beginning of the circuit and is performed in constant depth, as single-qubit gates act on disjoint subsets of qubits and can therefore be executed simultaneously [23].

Access to the array (Example 4) is controlled by the index register $|j⟩$, whose size is logarithmic in the array length. Conditional cyclic rotations shift the array so that the selected element is moved into the first position $|v[0]⟩$, from which its content is transferred to the output register $|b⟩$. A final uncomputation stage restores the array to its original configuration, ensuring reversibility and preventing the accumulation of unwanted entanglement [15, 23].

From a complexity standpoint, indexed array access is realised with polylogarithmic depth. Each cyclic rotation can be implemented with depth $O(\log n)$ and size $O(n)$ [24, 13], and since $O(\log n)$ such rotations are applied, the overall depth of the access operation is $O({\log }^{2}n)$, while the total circuit size is $O(n\log n)$.

Although sorting is one of the oldest problems studied in computer science, it remains a fundamental task, underpinning a vast range of algorithms and computational workflows [12]. Bubble Sort [20] is often regarded, in the muggle world of classical algorithms, as a pedagogical curiosity rather than a practical sorting technique. Its simplicity comes at the price of poor asymptotic performance, and more efficient methods are typically preferred whenever large datasets are involved. Nevertheless, Bubble Sort possesses a structural regularity that makes it an unexpectedly appealing candidate for illustrating high-level array manipulation in a quantum programming language.

In Qutes, the interest of Bubble Sort does not lie in its classical time complexity, but in the way its logic can be expressed through a small number of composable spells. At each iteration, the algorithm alternates between global comparison phases and parallel conditional transpositions, closely matching the divination and transposition spells introduced in the previous sections [23, 24]. What appears as a naive algorithm at the classical level thus becomes a remarkably clean orchestration of high-level quantum operations.

From a magical perspective, Bubble Sort can be seen as a repeated ritual in which local disorder is gradually revealed and corrected. Divination spells expose adjacent inversions, while transposition spells act in parallel to restore order, pushing larger elements toward their destined positions. Crucially, each step operates on the array as a whole, without requiring the programmer to track individual qubit movements or intermediate circuit states [13].

While the underlying circuit realization inevitably involves multiple layers of controlled operations and incurs non-trivial depth, this complexity remains entirely hidden at the language level. The resulting program offers a compact and declarative description of sorting, emphasizing clarity and structure over low-level efficiency. In this sense, Bubble Sort serves not as an endorsement of inefficiency, but as a compelling demonstration of how Qutes transforms even the simplest classical algorithms into expressive and conceptually elegant quantum spells.

The procedure Qute-Bubble-Sort(v,n) depicted above implements a well-known odd–even variant of Bubble Sort [20], expressed in a form that matches the transposition spell introduced earlier. The outer loop, indexed by $k$, performs $n-1$ passes over the array. Each pass is meant to reduce local disorder by eliminating adjacent inversions, gradually pushing larger elements toward the right end of the array (and, symmetrically, smaller elements toward the left), until the whole sequence becomes sorted.

The key idea lies in the inner loop, which alternates between two complementary sets of adjacent pairs. The starting index is $(kmod2)$: when $k$ is odd the loop starts from $i=1$, and when $k$ is even it starts from $i=0$. This alternation partitions the array into disjoint adjacent pairs. Concretely, in an even pass the algorithm considers the pairs

$(0,1),(2,3),(4,5),\mathrm{\dots }\text{whereas in an }\text{odd}\text{ pass it considers }(1,2),(3,4),(5,6),\mathrm{\dots }$

In both cases, the step size $2$ ensures that no element belongs to more than one pair within the same pass. This is exactly what enables the annotation parallel: all comparisons v[i] > v[i+1] refer to disjoint pairs and can therefore be evaluated concurrently, and the resulting conditional swaps can likewise be executed in a single transposition layer [23].

Within each selected pair, the if statement performs a local correction: if the left element exceeds the right one, a swap is applied, removing that inversion. Each pass thus acts as a localized “sorting wave” that fixes inversions on half of the edges of the array; the following pass targets the complementary edges. By repeatedly alternating these two phases for $n-1$ rounds, every element has the opportunity to move step by step toward its final position. In other words, the algorithm can be understood as a simple ritual of successive divination and transposition: adjacent disorder is detected and immediately corrected, but always in a way that preserves full parallelism within each round.

The circuit obtained by compiling the Qutes procedure Qute-Bubble-Sort(v,n) for a concrete instance with $n=4$ array elements, each encoded on $d=2$ qubits, is shown in Figure 7. The circuit exhibits the characteristic odd–even structure of the algorithm: each outer iteration $k$ selects a family of disjoint adjacent pairs, computes in parallel the predicates $v[i]>v[i+1]$ (divination), and then applies the corresponding controlled swaps (transposition) to those same disjoint pairs. At the circuit level, this is realised by (i) instantiating one comparison subcircuit per active pair to coherently write the outcome into a control qubit (or a small ancillary workspace), and (ii) using these outcomes as controls for a layer of conditional transpositions acting on the data qubits of the array [23, 24]. Since the pairs within a phase are disjoint, all comparisons (and swaps) within that phase can be scheduled in parallel, which is precisely the semantic meaning of the parallel annotation in Qutes. Finally, any ancillary information created by the comparison stage is uncomputed to restore workspace qubits and prevent unwanted entanglement from accumulating [23].

The above construction generalises directly to arrays of $n$ elements, each represented by $d$ qubits. In a single odd–even phase, the algorithm processes $p=\mathrm{\Theta }(n)$ disjoint adjacent pairs (specifically, $p=\lfloor n/2\rfloor$). Each pair requires one $d$-bit greater-than predicate; with the standard lexicographic cascade, a single > instance can be implemented with depth $O(d)$ and size $O(d)$, and (when workspace must be cleaned) an additional uncomputation stage contributes only a constant-factor overhead [23]. Because all $p$ comparisons act on disjoint qubits, the phase depth remains $O(d)$, while the phase size scales linearly as $O(pd)=O(nd)$. The subsequent controlled transposition layer consists of $p$ controlled swaps on $d$-qubit elements, which can be implemented with size $O(d)$ per pair and constant depth (up to the chosen decomposition of a controlled-SWAP gate), hence contributing $O(nd)$ size and only $O(1)$ additional depth [23, 13]. Since the outer loop performs $n-1=\mathrm{\Theta }(n)$ phases, the overall circuit depth for Qute-Bubble-Sort is $D(n,d)=\mathrm{\Theta }(n\cdot d),$ where the $d$ factor reflects the intrinsic bit-significance dependency of comparisons. The overall circuit size is $S(n,d)=\mathrm{\Theta }(n\cdot nd)=\mathrm{\Theta }(n^{2}d),$ as each of the $\mathrm{\Theta }(n)$ phases contains $\mathrm{\Theta }(n)$ pairwise operations, each costing $O(d)$ gates. Thus, while Bubble Sort remains asymptotically quadratic in circuit size (as expected), Qutes exposes a structured parallelism that keeps each phase shallow (polylogarithmic in the element domain size $2^d$) and expresses the entire construction as a compact composition of divination and transposition spells.

We conclude this section by clarifying its relationship with known lower bounds for sorting. In the circuit model, depth provides a natural notion of execution time on a quantum machine, as it captures the number of sequential layers of operations that cannot be parallelised [23], while circuit size measures the total amount of work performed.

The quadratic size reflects the fact that the algorithm performs $\mathrm{\Theta }(n^2)$ pairwise comparisons overall, exceeding the lower bound of $\mathrm{\Omega }(n\log n)$ comparisons required to sort an arbitrary input [20]. This is consistent with classical and quantum decision-tree lower bounds, which constrain the number of comparisons but do not restrict their degree of parallelisation [23].

If $d=\mathrm{\Theta }(\log n)$, corresponding to elements drawn from a polynomial-size domain, the circuit depth becomes $\mathrm{\Theta }(n\log n)$, matching the classical lower bound up to constant factors. When the element size is smaller, and in particular when $d=o(\log n)$ or even $d=O(1)$, individual comparisons can be implemented with sublogarithmic or constant depth, and the overall circuit depth reduces to $\mathrm{\Theta }(n)$. While the total circuit size remains quadratic, the depth (and the execution time) becomes asymptotically smaller than the classical $\mathrm{\Omega }(n\log n)$.

This separation between size and depth is not an artefact of Bubble Sort itself, but a consequence of the circuit model and of how parallelism is exposed. Unlike classical analyses, which collapse all operations into a single sequential cost, the circuit model distinguishes total work from independent execution layers. As a result, algorithms that are suboptimal in size may still be attractive when circuit depth is taken as the primary measure of running time. In this sense, the construction exhibits a genuine quantum advantage in parallel time when $d=o(\log n)$, arising from the ability to evaluate many independent comparisons simultaneously rather than from a reduction in total informational complexity.

This work explored how high-level, array-oriented abstractions can reshape how quantum algorithms are expressed and reasoned about. Rather than pursuing asymptotic performance improvements, the primary goal of Qutes is to close the gap between algorithmic intuition and executable quantum programs. By elevating common patterns, such as parallel comparison, controlled transposition, and indexed access, to first-class language constructs, Qutes allows programmers to describe quantum algorithms at a level that reflects their conceptual structure.

The quantum Bubble Sort case study illustrates this philosophy clearly. Although the underlying circuit respects known classical and quantum lower bounds, the corresponding Qutes program exposes a clean and highly parallel structure built from a small set of composable spells. The resulting circuit depth reflects the true sequential dependencies of the problem, while the complexity of gate orchestration, ancilla management, and uncomputation is delegated to the compiler. In this sense, Qutes does not obscure computational costs, but reorganises them in a way that is both explicit and meaningful at the algorithmic level.

This separation between semantic simplicity and circuit-level complexity highlights a fundamental trade-off in quantum programming languages. Low-level frameworks offer maximal control and optimisation opportunities, but force programmers to reason in terms of qubits, gates, and wiring. High-level abstractions, by contrast, may sacrifice some fine-grained control, but they are essential for scalability, readability, and correctness when algorithms grow beyond toy examples. Our results suggest that expressive, spell-like constructs are not merely syntactic sugar, but a necessary ingredient for managing the inherent parallelism and global behaviour of quantum computation.

Looking forward, the abstractions presented here open several directions for future work. Extending the repertoire of array spells, exploring optimisation strategies that preserve high-level semantics, and studying the interaction between such abstractions and fault-tolerant compilation are all natural next steps. More broadly, as quantum hardware continues to evolve, the success of quantum software will increasingly depend on languages that allow programmers to think and reason like wizards, not like circuit engineers. Wizard machines deserve better spells, and Qutes is a step in that direction.