Procedural generation using quantum computation
PProcedural generation using quantum computation
James R. Wootton
IBM Quantum, IBM Research - Zurich
Abstract —Quantum computation is an emerging technologythat promises to be a powerful tool in many areas. Though someyears likely still remain until significant quantum advantage isdemonstrated, the development of the technology has led to arange of valuable resources. These include publicly availableprototype quantum hardware, advanced simulators for smallquantum programs and programming frameworks to test anddevelop quantum software. In this provocation paper we seekto demonstrate that these resources are sufficient to providethe first useful results in the field of procedural generation.This is done by introducing a proof-of-principle method: aquantum generalization of a blurring process, in which quantuminterference is used to provide a unique effect. Through this wehope to show that further developments in the technology arenot required before it becomes useful for procedural generation.Rather, fruitful experimentation with this new technology canbegin now.
Quantum computation is a new technology based on aradically new form of hardware and software [1]–[3]. This willallow certain problems to be solved with a significant reductionin computational complexity in comparison with conventionaldigital computing [4], [5]. The resulting ‘quantum speedup’varies from polynomial to super-polynomial or even expo-nential for algorithms address a variety of different types ofproblem [6], [7].The basic unit of quantum computation is the qubit. To runmost of the algorithms developed over the past few decades,thousands of qubits will be required. Quantum processors ofthis size do not currently exist, and are still some years away.At the other extreme, any small scale quantum process of up toaround 20 qubits can easily be simulated by a laptop, and upto around 50 qubits can be simulated by a supercomputer [8],[9].Currently, most prototype quantum devices have no morethan 20 qubits, and it is devices of up to this size that havebeen made publicly available through cloud services [10].These have found a great deal of use by those seeking totest and understand quantum processors, such as those usingthem as experimental hardware to perform studies relatingto the science behind the devices. However, as pieces ofcomputational hardware, the fact of their easy simulability byconventional computers means that they cannot yet provide anadvantage over conventional hardware.Nevertheless, by considering the methodology required forquantum computing, we can start to think about how quantumalgorithms can be used in different fields. For proof-of-principle cases of up to 20 qubits, we can easily implementthese methods either by simulation or using prototype devices. For the most part, the results of these proof-of-principleimplementations are not useful in themselves. However, insome cases we may find that they do indeed offer a uniqueinsight that might not have been considered outside the contextof quantum computation. Such a case would not representan advantage of using quantum hardware over conventionalhardware, since it is just as easy to use conventional hardwarein a simulation. Instead it would represent an advantage ofdesigning software using quantum principles.In this paper, we suggest that procedural generation is oneof the most likely fields in which such initial advantages mightbe found. The popular ‘wave function collapse’ algorithmcould be thought of as foreshadowing this [11], since it is aquantum inspired method that has proven very useful to manypractitioners of procedural generation. However, it is not anexample in itself since it was not designed using the principlesof quantum computing software.To provide a more substantial motivating example, we mustfocus on finding applications for the kind of results thatquantum computers find easiest to produce. These includesimulations of quantum dynamics, and the generation ofquantum interference effects. An example of how the formermight be used in procedural generation can be found in [12],where it was shown that quantum simulations can provide arudimentary AI for a
Civilization -like game. For the latter wecan look to ideas such as quantum walks [13], which provide ageneralization of familiar random walks. It is a simple exampleof such a process that we will consider below, as a uniquemeans of providing a blur effect.I. I
NTRODUCTION TO QUANTUM COMPUTATION
Before we consider an application of quantum computing,it is first necessary to explain the basic principles of quantumsoftware. In this we will focus on the aspects that are mostrelevant for the application that we will consider.As with standard digital computers, we begin with theconcept of the ‘bit’. These are objects that are limited to twopossible states, often denoted and . Most forms of hardwareused to encode this information are governed by the laws ofclassical physics, which means that the bit value is definitelyeither or . However, it is also possible to create hardwarein which the bit value is governed by the laws of quantumphysics. To describe this, it is useful to associate the bit valueswith a pair of orthogonal vectors, written as | (cid:105) and | (cid:105) .When we read out the bit value from such a quantum bitor ‘qubit’, the states | (cid:105) and | (cid:105) will behave as one would a r X i v : . [ c s . ET ] J u l xpect: from | (cid:105) we read out , and from | (cid:105) we read out .However, quantum physics also allows states of the form c | (cid:105) + c | (cid:105) , where the so-called ‘amplitudes’ c and c are arbitrarycomplex numbers that satisfy | c | + | c | = 1 . Such statesare known as ‘superposition states’.Reading out the bit value from a qubit in a superpositionstate will still result in a simple or . However, the outputwill be random in this case. Specifically, will occur withprobability | c | and with probability | c | . Once the bitvalue has been read out, the superposition state ‘collapses’to the corresponding state | (cid:105) or | (cid:105) . For example, afterobtaining the output , the qubit will no longer be in asuperposition state but instead will be in the simple state | (cid:105) .This effect means that keeping track of the bit value is not apassive process, as it is in the classical case. Instead it has theability to change the state of the qubit. As such, we must becareful to specify exactly when we want such readout events,known as measurements, to occur.Superposition states are more than simply a source of ran-domness. They allow a wider variety of methods to manipulatethe bit. Classically, there is a very limited set of operationsthat can be performed on just a single bit: set it to , setit to or flip the value with a NOT gate. In the quantumcase, however, we can perform any of an infinite set ofparameterised operations. All of these can be generated bythe operations R x ( θ ) and R y ( θ ) , which have the followingeffect. R x ( θ ) | (cid:105) = i cos θ | (cid:105) + sin θ | (cid:105) ,R x ( θ ) | (cid:105) = sin θ | (cid:105) + i cos θ | (cid:105) ,R y ( θ ) | (cid:105) = cos θ | (cid:105) + sin θ | (cid:105) ,R y ( θ ) | (cid:105) = − sin θ | (cid:105) + cos θ | (cid:105) . Note that R x ( π ) has the effect | (cid:105) ↔ | (cid:105) . The R x operationtherefore reproduces and generalizes the effect of the NOT gate. Similarly, R y ( π/ has the effect | (cid:105) → | (cid:105) and | (cid:105) →− | (cid:105) . The factor of − in the latter has no effect on theprobabilities for the results of a measurement, and so R y alsoreproduces and generalizes the effect of the NOT gate, but ina different way to that done by R x .We have now seen that the quantum implementation of bitsallows a greater variety of possible manipulations. However,we have not yet seen any example of why this may beadvantageous. All such examples require the use of more thanjust one qubit. For two qubits, the possible states take the form c | (cid:105) + c | (cid:105) + c | (cid:105) + c | (cid:105) The probability of obtaining the outcome described by eachtwo bit string b b is | c b b | , and the complex numbers c b b must obey the restriction (cid:80) b b | c b b | = 1 . For n qubits thestates take a corresponding form using n -bit strings.So far we have introduced only single qubit manipulations.These must be supplemented with multi-qubit operations inorder to perform computation. The most important of theseis the so-called ‘controlled- NOT ’ or cx gate, which acts on agiven pair of qubits. The effect is not symmetric, and so onequbit is designated the ‘control’, and the other is the ‘target’.The effect is as follows, with the control in these exampleswritten on the left. cx | (cid:105) = | (cid:105) , cx | (cid:105) = | (cid:105) , cx | (cid:105) = | (cid:105) , cx | (cid:105) = | (cid:105) . We can think of this operation as performing a
NOT on thetarget qubit iff the control qubit is in state | (cid:105) . Alternatively,we can think of it as overwriting the target qubit state with the XOR of the inputs. In this sense it is a quantum (and reversible)implementation of the classical
XOR gate.Given just the ability to perform the R x , R y and cx gates on all qubits, it is possible to transform any multi-qubitstate into any other. In fact, it is possible to implement anymapping from a set of input bit strings to output bit strings,and so to reproduce any classical computation. However,this does not just provide an alternative form of hardwareon which to implement the same algorithms as for digitalcomputers. Instead, it provides a unique way of manipulatinginformation , leading to a variety of unique algorithms thatcan be implemented with quantum computation [7].By considering the ‘textbook’ quantum algorithms devel-oped over the past few decades [6], we can begin to spec-ulate on how they will be used in procedural generation.In particular the reduced computational complexity for con-straint satisfiability problems could be useful in searching theprobability space (for example [14], [15]), and speed-ups forgraph-theoretic analysis could help to find useful properties ofproblems expressed as networks (for example [16]). However,the usefulness of these algorithms will depend on exactly whattime and resources are required [17]. This will not be fullyknown until the scalable and fault-tolerant quantum hardwarerequired to run these algorithms has been built, which isstill some years away. However, these potential opportunitiesshow that quantum computation will be useful for proceduralgeneration in the long-term, which provides motivation toexplore applications in the near-term.II. E NCODING IMAGES IN QUANTUM STATES
Using the concepts introduced in the last section, we willintroduce a method to encode and manipulate images using As a quick plausibility argument for this, note that a
NAND gate cannotbe constructed in the Boolean circuit model using
NOT and
XOR gates alone.However, this can be achieved in the quantum circuit model using only thequantum generalizations of the
NOT and
XOR gates. This is a simple exampleof a computational task that quantum computaters can achieve in a way thatstandard digital computers cannot. ultiqubit states. Specifically, the manipulation will be toimplement a blur like effect using quantum interference. Wewill consider grayscale images, in which the brightness of apixel corresponds to a value from to . We can equivalentlyconsider these images to be height maps, and will sometimesrefer to them as such.Code snippets are provided to show explicitly how themethod can be generated. These are in Python, and will usethe Qiskit framework for handling quantum circuits [18]. Firstwe begin by importing the necessary tools. import numpy as npfrom math import pifrom qiskit import QuantumCircuit, quantum_info as qi For other languages, note that MicroQiskit could beused [19]. This is a minimal reimplementation of Qiskit,designed to facilitate ports to other programming languages.The following methods can be used in MicroQiskit with almostidentical syntax.
A. Converting images to quantum states
Though we are focussing on small-scale quantum processesof up to around 20 qubits, we will want to use them to generateimages with thousands of points. Clearly there is a differenceof scale between the two. However, as we saw above, thestate of n qubits is described by a set of n amplitudes: onefor each possible output bit string. We can therefore close thegap by making use of all of these amplitudes, or alternativelythe corresponding probabilities.When using a real quantum processor, the state cannot beaccessed directly. Instead we need to estimate the probabilitiesfor each of the n possible output bit strings. This can be doneby repeating a circuit many times to sample from the output.Specifically, using shots = 4 n samples should be adequate toestimate the probabilities with sufficient accuracy. However,this number of samples carries a computational complexitythat is greater than the O (2 n ) required to directly access theprobabilities when a simulation is used. The method we willdevelop is therefore one for which the use of a simulator is infact advantageous over the use of a real quantum device: thereverse of what is normally found in quantum computing.Our first task is to find a mapping between the numbersthat describe an image (brightness values for each coordinate)and the numbers that describe a quantum state (amplitudes foreach output bit string). The most important element of this is todefine a mapping between the coordinates and the bit strings.The ideal mapping for our purposes would be one thatmaps neighbouring coordinates to neighbouring bit strings. Forexample, if we map some ( x, y ) to , a good choice forneighbouring points would be ( x + 1 , y ) → ( x − , y ) → , ( x, y + 1) → , ( x, y − → . Here the Manhattan distance between any two points isequal to the Hamming distance between the corresponding bitstrings.In general, this will not be a perfect mapping. We usuallyconsider images based on 2D square lattices, whereas thestructure formed by the Hamming distance between n -bitstrings is an n -dimensional hypercube. This will mean thatthere will always have to be non-neighbouring coordinates (onthe lattice) whose bit strings are neighbours (in the hypercube).However, we can at least ensure that neighbouring coordinatesalways have neighbouring bit strings.This is done using repeated applications of a process inwhich we take such a list for n -bit strings and use it to createa list with doubled length for ( n + 1) -bit strings. This processstarts by creating two altered copies of the original list. Forthe first copy, we simply add a to the end of each bit string.For the second we reverse the order and then add a to theend of each bit string. Finally, these two lists are concatenated.For example, starting with [ , ] we get [ , ] for theoriginal list with appended , and [ , ] for the reversed listwith appended . These combine to form [ , , , ] . Byrepeating the process, we can obtain a list of length n for n -bit strings for any desired n .The process can be applied by the following Python func-tion. Given a desired length for the list, this returns a list ofat least that length. def make_line ( length ):n = int(np.ceil(np.log(length)/np.log(2)))line = [’0’,’1’]for j in range(n-1):cp0 = []for string in line:cp0.append (string+’0’)cp1 = []for string in line[::-1]:cp1.append (string+’1’)line = cp0+cp1return line With this, we can combine the x th and y th elements oftwo such lists to define a unique string for each coordinate ( x, y ) of a grid. The following function, make_grid runsthrough all the coordinates of an L × L grid, calculates thecorresponding bit string, and then outputs all the results. Thisis done as a Python dictionary, with bit strings as keys andthe corresponding coordinates as values. def make_grid(L):line = make_line( L )grid = {}for x in range(L):for y in range(L):grid[ line[x]+line[y] ] = (x,y)return grid Now we have figured out what to do with the coordinatesin an image, it is time to focus on the brightness valuesthemselves. To do this, we will assume that each value h exists in the range ≤ h ≤ , and that the largest of allthe heights is equal to exactly . This assumption is withoutoss of generality, since any set of values can be shifted andrescaled into this form.We then define a quantum state for which the probabilityof a bit string b is proportional to the brightness of thecorresponding point grid [ b ] , p b (cid:48) p b = h grid [ b (cid:48) ] h grid [ b ] The reason why we cannot simply set p b = h grid [ b ] isbecause probabilities must always sum to 1. To achieve thiswe simply renormalize using p b = h grid [ b ] H , H = (cid:88) b h grid [ b ] . Now we have the probabilities, we need correspondingamplitudes for the basis states. When we restrict to the casethat these amplitudes are real numbers, they are related to theprobability by the simple relation c b = √ p b . The state werequire to encode our image is then √ H (cid:88) b (cid:112) h b | b (cid:105) Now we can construct a function to create this state for anygiven image. This means that we need to create a ‘quantumcircuit’, a set of operations for a suitable number of qubitswhich will prepare the required state from the default initial | . . . (cid:105) state. Rather than dwell on the details of this atan abstract level, we can simply use Qiskit in which quantumcircuits are defined within a QuantumCircuit class, whichincludes an initialize method that can be used to setdesired initial states.The images that we will manipulate in the following will beexpressed in the form of Python dictionaries, with coordinatesas keys and the corresponding brightness as values. Absentcoordinates are assumed to correspond to a value of 0. Hereis an example of such an image. height = {}for pos in [(2,5),(2,6),(5,6),(5,5),(2,1),\(3,1),(4,1),(5,1),(1,2),(6,2)]:height[pos] = 1
The following function allows us to convert a given imageto a quantum circuit. def height2circuit(height):
B. Converting quantum states to images
The next job is to implement the opposite process: to turn aquantum circuit into an image. For this we must determine theprobability p b for each possible output bit string b . In the casethat we are simulating the process we can keep track of theentire quantum state. The probabilities p b can then be extracteddirectly, as in the circuit2height function below. def circuit2height(qc): If we were instead to use real quantum hardware, the processwould be slightly more involved. Firstly, to obtain the outputbit string we would need to measure the qubits. The mea-surement of all qubits can be done by adding measurementsto the end of the circuit using qc.measure_all() . Eachrun of the circuit then returns a bit string b , drawn fromthe probability distribution described by the probabilities p b .To estimate these probabilities we must then run the circuitfor many samples, and count the number of runs that giveeach output. These results can be expressed as a so-called counts dictionary, for which counts [ b ] represents the numberof samples for the bit string b . This is done with result = execute(qc, backend, shots=shots).result()counts = result.get_counts() where backend describes the device on which the circuit qc , and shots is the number of samples for which the processis repeated.By dividing each of the counts values by shots , whichspecifies the total number of runs, we obtain an estimationof the probabilities. However, since we must rescale thesevalues in any case to regain the original image (to ensurethat the maximum value is equal to ), we can simply use thecounts values directly instead of the probabilities. Note that, a)(b) (c) Fig. 1: (a) A simple face encoded in and then recovered froma quantum circuit. (b) The image after an R y ( π/ gate on allqubits. (c) The same image as in (b), but with values plottedlogarithmically.as mentioned earlier, the overhead of sampling shots timesmeans that running on real quantum hardware is less efficientfor this specific application.However we run the process in circuit2height , incombination with height2circuit we can now implementthe simple process of encoding and then recovering the exam-ple image height . qc = height2circuit(height)new_height = circuit2height(qc,backend) More interesting is to manipulate the image by addingquantum gates to the circuit. Though there are many possiblechoices we could make of what gates to apply, we considersomething very straightforward: simply applying R y to allqubits by a given angle θ . The results are shown in Fig. 1.Note that the effect appears very slight, due to the blurringoccurring with an exponential distribution. The effect can beseen more clearly when the values are plotted logarithmically.The fact that the blur effect is due to an interference processcan be most easily seen when large angles are used. This isshown in Fig. 2, where the initial two-pixel images representsthe so-called GHZ state [20].Here the small angles show a relatively simple blurringeffect. However, rather than simply blurring out into a uniformdistribution, the interference effects at θ = 0 . π create acheckerboard pattern. Larger angles would see the originalpoints reform, leading to the original image at θ = π . The (a) (b)(c) (d)(e) (f) Fig. 2: A rotation of the GHZ state by (a) θ = 0 , (b) θ = 0 . π ,(c) θ = 0 . π , (d) θ = 0 . π , (e) θ = 0 . π , (f) θ = 0 . π , all.plotted logarithmically.interference pattern at θ = 0 . π depends strongly on the initialstate, and so would be different if other pixels were chosen inthe original image. C. Applications of the method
The quantum blur method presented has been developedand tested during projects for various game jams. It wasprimarily used to procedurally generate textures from simpleseed images. Some of these applications are outlined below.The first use in a game jam was for PyWeek 27 in which itwas used as the basis for an art toy: the ‘Quantograph’ [21].This allowed users to choose a seed image as well as set of pa-rameters. Multiple quantum circuits based on these parameterswere then implemented, each slightly different from the last,to create successive frames for an animation. This provideda visualization of quantum interference effects distorting theseed image. In this project, the method presented in therevious sections was adapted to allow for colour images. Thiswas done simply by running three different quantum processes,with one for each rgb colour channel. Similar animations werealso used in a game for the GMTK Game Jam 2019 [22]. Inthis case it served as a transition animation, where the screenwas scrambled and unscrambled by the quantum process whentransitioning between levels.As an extension of this idea, transitions between twoseed images can be achieved using a teleportation-like effect.Specifically using the
SWAP gate, which acts on two equalsized registers of qubits, and simply swaps their states. Justas R x and R y can be viewed as fractional forms of the NOT gate, so too can we define fractional forms of the
SWAP gate.By encoding two different images in different registers ofqubits, and then applying different fractions of the
SWAP gateto generate images for different frames, we can visualize theintermediate states of this quantum
SWAP operation, creatingan animation of a teleportation-like effect. An example of thisfor few-pixel images is shown in Fig. 3.In Ludum Dare 44 [23], the quantum blur effect was usedto generate maps on which a simple game was played. Anexample of the method used is depicted in Fig. 4. Specifically,the × patch of texture in Fig. 4 (b) is created fromthe randomly generated seed image of Fig. 4 (a). Hundredsof random variants of this are then created by a shufflingprocess, in which alternative mappings between bit stringsand coordinates are randomly generated and the correspondingimages are constructed using the same set of probabilities eachtime. This generates hundreds of textures while only usingthe quantum process once, with an entire time taken of lessthan 10 seconds on a laptop. These textures are then randomlyplaced onto a × pixel image, where the probabilityof placement at at given point is governed by the height of apredetermined simple layout. The × pixel layout in Fig. 4(c) is used in the example (stretched out to the required size).With this whole process the island of Fig. 4 (c) was generated,where colours represent the type of terrain at different heights.During PROCJAM 2019 [24], the above method wasadapted to create islands suitable to be rendered in 3D, asshown in Fig. 5. This was done using a voxel based gameengine, meaning that the height was rounded down at eachpoint. This left a value ≤ r < at each point as thedifference between the true and rounded values. These valueswere used to decide the position of objects such as trees.This method was subsequently used in the educational gameQiskitBlocks [25].The method has also been applied to other forms of discretedata, using the results of make_line as a starting point forthe mapping. For example, we can consider a given musicalnote to be located in a 3D space consisting of coordinatesdescribing which bar it is in, placement within that bar, andits octave. Each coordinate corresponds to a line of bit stringsof suitable length, and the total coordinate corresponds to thecombination of these bit strings. With this we can then convertmusic to and from quantum states, and the ‘blurring’ effectof quantum gates will cause notes to bleed across bars, and (a) (b)(c) (d)(e) (f)(g) (h) Fig. 3: Transition between a plumber and a flower. The smallsize of these images is not a limitation of the method, but waschosen in line with the theme of a game jam. a) (b)(c) (d)
Fig. 4: (a) A randomly chosen × pixel seed image. (b)The seed image with θ = 0 . π , plotted logarithmically. (c)A simple × pixel layout for an island. (d) A × pixel island with texture generated by random placement ofthe manipulated seed image over the simple island layout.Fig. 5: An island generated using the quantum blur effect,and rendered in 3D in QiskitBlocks. between different bars and octaves.III. C OMPARISON TO OTHER METHODS
When comparing to other methods, the most obvious com-parison is to the box blur. For an L × L image, a blur of anyradius r , can be done with just O ( L ) complexity [26]: linearin the number of points.The quantum blur presented here uses the simulation of n = (cid:6) log ( L ) (cid:7) qubits, which requires manipulation of avector of length n . The blur effect is provided by performinga rotation gate on all qubits. Doing these individually wouldresult in a total complexity of O ( n n ) = O ( L log L ) . This isnot significantly worse than the box blur, and methods could befound to improve the complexity. Nevertheless, the quantummethod cannot beat the complexity of the standard box blur.Furthermore, content generated by the quantum method hasartefacts that result from quantum interference effects and theway that large images are squeezed into a small number ofqubits (primarily the effects of non-neighbouring points havingneighbouring bit strings). Such artefacts, which make it obvi-ous that the content was generated algorithmically and whichprovide noticeable traces of the algorithm used, are usuallyregarded as being problematic in procedural generation [27].Significant efforts are therefore typically made to avoid sucheffects. However, these artefacts might actually prove usefulin the quantum case. This is because quantum computing is anarea which is of interest to many people, not just because of theresults that it will provide but also because of the connectionthat the hardware and software have to the science of quantumphysics. Since quantum physics is a popular topic used (ormisused) in science fiction, artefacts which provide a signatureof a quantum origin could help to build a desired aesthetic ina sci-fi context, or provide the player with the sense of a moregenuine sci-fi experience.The idea that quantum artefacts may be beneficial for someuse cases is inspired by the way that external parties havealready been using the method proposed here. Nevertheless,this idea is primarily speculation at this stage. Studies intothe public perception of procedurally generated content has sofar only been done for standard computational methods [28].However, it might now be timely to perform similar studiesinto the perception of quantum results.Nevertheless, it is not the intent in this paper to proposea method suitable solely for sci-fi projects, as the examplesshown in the last section should demonstrate. However, thismay well be a niche for which quantumly generated contentcan excel within the near-term.IV. C ONCLUSIONS
For many applications, the usefulness of quantum comput-ing will begin once the hardware is able to implement the thou-sands of qubits needed for standard textbook algorithms [7],[29], [30]. For other applications, a quantum advantage willbe found for nearer term devices with hundreds of qubits [31].For a few applications, however, designing algorithms usingthe principles of quantum computing could be a useful ventureven while those algorithms can be run more easily on con-ventional computers than quantum hardware. In these cases,the design of immediately useful quantum methods can beginnow, and will only grow in usefulness and sophistication asever more powerful quantum hardware emerges.The quantum blur effect presented here shows that procedu-ral generation is such a case. It is targeted specifically at usingsimulators or currently available prototype quantum hardware,and uses quantum operations to create an effect that couldbe useful for various tasks within procedural generation. It isclearly a very simple tool, and is not expected to become thefirst ‘killer app’ of the quantum era in itself. Nevertheless,it shows the potential that quantum computing can haveeven with current computational resources, and will hopefullyinspire others to investigate what quantum computing can dofor them. A
CKNOWLEDGMENTS
Thanks to the organizers and participants of the PyWeek,Ludum Dare, GMTK and PROCJAM game jams, at whichmuch of this work was performed.R
EFERENCES[1] P. Benioff, “The computer as a physical system: A microscopic quantummechanical hamiltonian model of computers as represented by turingmachines,”
Journal of Statistical Physics , vol. 22, no. 5, pp. 563–591,1980. [Online]. Available: https://doi.org/10.1007/BF01011339[2] R. P. Feynman, “Simulating physics with computers,”
InternationalJournal of Theoretical Physics , vol. 21, no. 6, pp. 467–488, 1982.[Online]. Available: https://doi.org/10.1007/BF02650179[3] M. A. Nielsen and I. L. Chuang,
Quantum Computation and QuantumInformation . Cambridge: Cambridge University Press, 2000.[4] D. Deutsch and R. Jozsat, “Rapid solution of problems by quantumcomputation,” in
IN PROC , 1992, pp. 553–558.[5] A. Montanaro, “Quantum algorithms: an overview,” npj QuantumInformation , vol. 2, no. 1, p. 15023, 2016. [Online]. Available:https://doi.org/10.1038/npjqi.2015.23[6] S. Jordan, “Quantum algorithm zoo,” 2020. [Online]. Available:https://quantumalgorithmzoo.org/[7] A. Asfaw, L. Bello, Y. Ben-Haim, S. Bravyi, L. Capelluto, A. C.Vazquez, J. Ceroni, J. Gambetta, S. Garion, L. Gil, S. D. L. P.Gonzalez, D. McKay, Z. Minev, P. Nation, A. Phan, A. Rattew,J. Schaefer, J. Shabani, J. Smolin, K. Temme, M. Tod, and J. Wootton.,“Learn quantum computation using qiskit,” 2020. [Online]. Available:https://qiskit.org/textbook[8] F. Arute et al., “Quantum supremacy using a programmablesuperconducting processor,”
Nature , vol. 574, no. 7779, pp. 505–510,2019. [Online]. Available: https://doi.org/10.1038/s41586-019-1666-5[9] E. Pednault, J. A. Gunnels, G. Nannicini, L. Horesh, and R. Wisnieff,“Leveraging Secondary Storage to Simulate Deep 54-qubit SycamoreCircuits,” 2019, arXiv:1910.09534.[10] A. D. Corcoles, A. Kandala, A. Javadi-Abhari, D. T. McClure, A. W.Cross, K. Temme, P. D. Nation, M. Steffen, and J. M. Gambetta, “Chal-lenges and Opportunities of Near-Term Quantum Computing Systems,”2019, arXiv:1910.02894.[11] M. Gumin, “Wavefunctioncollapse,” 2016. [Online]. Available: https://github.com/mxgmn/WaveFunctionCollapse[12] J. R. Wootton, “A quantum procedure for map generation,” in , 2020.[13] V. Kendon, “How to compute using quantum walks,” in
Proceedings 9thInternational Conference on Quantum Simulation and Quantum Walks ,2020.[14] A. Smith and M. Mateas, “Variations forever: Flexibly generatingrulesets from a sculptable design space of mini-games,” in , 09 2010, pp. 273– 280. [15] G. Smith, J. Whitehead, and M. Mateas, “Tanagra: Reactive planning andconstraint solving for mixed-initiative level design,”
IEEE Transactionson Computational Intelligence and AI in Games , vol. 3, pp. 201 – 215,10 2011.[16] B. A. Kybartas and C. Verbrugge, “Analysis of regen as a graph-rewriting system for quest generation,”
IEEE Trans. Comput. Intellig.and AI in Games , vol. 6, no. 2, pp. 228–242, 2014. [Online]. Available:https://doi.org/10.1109/TCIAIG.2013.2290088[17] E. Campbell, A. Khurana, and A. Montanaro, “Applying quantumalgorithms to constraint satisfaction problems,”
Quantum , vol. 3,p. 167, Jul. 2019. [Online]. Available: https://doi.org/10.22331/q-2019-07-18-167[18] Qiskit Contributors, “Qiskit: An open-source framework for quantumcomputing,” 2019.[19] J. R. Wootton, “Microqiskit,” 2020. [Online]. Available: https://github.com/qiskit-community/MicroQiskit[20] W. D¨ur, G. Vidal, and J. I. Cirac, “Three qubits can be entangled in twoinequivalent ways,”
Phys. Rev. A , vol. 62, p. 062314, Nov 2000.[21] J. R. Wootton, “’quantograph’, entry for pyweek 27,” 2019. [Online].Available: https://pyweek.org/e/Qiskitters/[22] ——, “’1d’, entry for the gmtk game jam 2019,” 2019. [Online].Available: https://decodoku.itch.io/1d[23] ——, “’.get memory()’, game for ludum dare 44,” 2019. [Online].Available: https://ldjam.com/events/ludum-dare/44/get-memory[24] ——, “’quantum island generator’, entry for procjam 2019,” 2019.[Online]. Available: https://decodoku.itch.io/quantum-island-generator[25] J. Weaver, “’qiskitblocks’ game.” 2019. [Online]. Available: https://github.com/JavaFXpert/QiskitBlocks/blob/master/README.md[26] W. Jarosz, “Fast image convolutions,” 2001, ACM SIGGRAPH@UIUC.[27] K. Backus, “Managing output: Boredom versus chaos,” in
ProceduralGeneration in Game Design . CRC Press, 2017, p. 45.[28] C. Lamb, D. G. Brown, and C. L. A. Clarke, “Evaluating computationalcreativity: An interdisciplinary tutorial,”
ACM Comput. Surv. , vol. 51,no. 2, Feb. 2018. [Online]. Available: https://doi.org/10.1145/3167476[29] P. W. Shor, “Polynomial-time algorithms for prime factorizationand discrete logarithms on a quantum computer,”
SIAM Review ,vol. 41, no. 2, pp. 303–332, 1999. [Online]. Available: https://doi.org/10.1137/S0036144598347011[30] L. K. Grover, “A fast quantum mechanical algorithm for databasesearch,” in
Proceedings of the Twenty-Eighth Annual ACM Symposiumon the Theory of Computing, Philadelphia, Pennsylvania, USA, May22-24, 1996 , G. L. Miller, Ed. ACM, 1996, pp. 212–219. [Online].Available: https://doi.org/10.1145/237814.237866[31] J. Preskill, “Quantum Computing in the NISQ era and beyond,”