Quantum generative adversarial network training method

Abstract

A computer-implemented method comprising training a quantum generative adversarial network, QGAN, comprising a quantum generator and a quantum discriminator, according to a QGAN training process comprising: generating, using a quantum encoder and based on training data, compressed latent representations of the training data; generating, using the quantum generator, synthetic compressed latent representations; generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the predictions, weights of the QGAN.

Description

[0001] QUANTUM GENERATIVE ADVERSARIAE NETWORK TRAINING METHOD

[0002] The present invention relates to data generation, and in particular to a computer-implemented method, a computer program, and an information programming apparatus.

[0003] Quantum computing is a type of computation that takes advantage of the quantum mechanical properties of matter, such as superposition and entanglement, to process information in fundamentally new ways. For example, the basic unit of information in quantum computing, the qubit, can exist in a superposition of two states, whereas the bit in classical (non-quantum) computing may be in only one of two states (a binary). Quantum computing provides possibilities for carrying out complex processing that would take longer using classical computing.

[0004] Machine learning is a subset of artificial intelligence (Al) that involves training algorithms to learn patterns and make decisions based on data, without being explicitly programmed for specific tasks. Quantum Machine Learning (QML) is an interdisciplinary field combining quantum computing with machine learning techniques. QML algorithms / models are designed for quantum computers.

[0005] Generating quantum data, for example quantum states, is an application of QML and it is desirable to improve the generation of quantum data and the training of QML model(s) for such generation.

[0006] The present invention is defined by the independent claims, to which reference should now be made. Specific embodiments are defined in the dependent claims.

[0007] According to an embodiment of a first aspect there is disclosed herein a computer- implemented method comprising training a quantum generative adversarial network, QGAN, comprising a quantum generator and a quantum discriminator, according to a QGAN training process comprising (performing adversarial training by): generating, using a (trained) quantum encoder and based on (first) training (quantum) data, compressed latent representations (matrice s / vectors) of / corresponding to the (first) training (quantum) data; generating, using the quantum generator, synthetic compressed latent representations (matrice s / vectors); generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the (correctness of the) predictions, weights / parameters of the QGAN.

[0008] Training a QGAN, for data generation, to learn the compressed latent space of a quantum autoencoder (QAE) in the context of some particular training data is more efficient than e.g. training a QGAN to learn the particular training data (i.e. the pattems / relations among the training data). The quantum generator, once trained, is able to generate compressed latent representations which may be decoded by the quantum decoder to provide quantum data which shares a property or aspect with the particular training data.

[0009] Reference will now be made, by way of example, to the accompanying drawings, in which:

[0010] Figure 1 is a diagram illustrating an autoencoder;

[0011] Figure 2 is a diagram illustrating a variational autoencoder;

[0012] Figure 3 is a diagram illustrating a quantum autoencoder;

[0013] Figure 4 is a diagram illustrating a generative adversarial network;

[0014] Figure 5 is a diagram illustrating methods;

[0015] Figure 6 is a diagram illustrating a circuit structure;

[0016] Figure 7 is a diagram illustrating a circuit structure;

[0017] Figure 8 is a flowchart illustrating a method;

[0018] Figure 9 is a flowchart illustrating a method;

[0019] Figure 10 is a flowchart illustrating a method;

[0020] Figure 11 is a flowchart illustrating a method;

[0021] Figure 12 is a flowchart illustrating a method;

[0022] Figure 13 is a diagram illustrating graphs;

[0023] Figure 14 is a diagram illustrating graphs;

[0024] Figure 15 is a diagram illustrating graphs;

[0025] Figure 16 is a diagram illustrating graphs;

[0026] Figure 17 is a diagram illustrating graphs;

[0027] Figure 18 is a diagram illustrating graphs;

[0028] Figure 19 is a diagram illustrating a computing device; and

[0029] Figure 20 is a diagram illustrating a computing device. Figure 1 is a schematic diagram illustrating an autoencoder (AE) 20 according to a comparative example. The AE 20 is a “classical” ML model to be implemented using “classical” computing. Herein, “classical” may be considered to mean “non-quantum”, in the sense that a distinction is drawn herein between quantum computing which uses qubits and classical or non-quantum computing which uses bits.

[0030] The AE 20 comprises an encoder 22 and a decoder 24, both of which comprise a neural network. The encoder 22 encodes input data x (using the encoder function e_theta) to output a latent vector z, which is a compressed representation of the input data x. That is, the encoder 22 compresses the data from a higher-dimensional space to a lower-dimensional space (also called the latent space). The decoder 24 decodes the latent vector z (using the decoder function d_phi) and outputs reconstructed input data x-hat. In other words, the decoder 24 converts the latent space back to the higher dimensional space (of the input data x).

[0031] The AE 20 is trained using the loss function shown in the Figure to minimize the difference between the input x and the reconstructed input x-hat to ensure that the latent space is able to capture most of the information in the higher-dimensional input data x. A standard AE has a non-regularised latent space which means that the standard AE 20 lacks generative capability.

[0032] Figure 2 is a schematic diagram illustrating a variational autoencoder (VAE) 30 according to a comparative example. The VAE 30 comprises an encoder 32 and a decoder 34, similarly to the AE 20. The VAE 30 additionally comprises a sampling function 33. The encoder 32 outputs parameters (mu and sigma - mean and standard deviation) of a distribution (which is pre-defined) in the latent space for every input x, and a constraint is imposed on this distribution (latent distribution) to force it to be a normal distribution (for this reason, the latent space in a VAE is said to be a regularised latent space). The sampling function 33 samples a latent vector z from the latent distribution and the decoder 34 decodes the sampled latent vector to generate a reconstructed input x-hat.

[0033] The VAE 30 is trained to minimize the difference between the input data and the reconstructed input while ensuring the latent space captures meaningful variations in the data. This is accomplished using the loss function which comprises a reconstruction loss and a similarity loss as shown in Figure 2. The VAE 30 has a regularised latent space and has generative capability.

[0034] Both the AE and VAE have been extended to the quantum regime and are called Quantum AE (QAE) and Quantum VAE (QVAE), respectively.

[0035] Figure 3 is a schematic diagram illustrating a QAE 40 according to a comparative example. The QAE 40 is a QML model to be implemented on quantum hardware. The QAE 40 comprises a quantum encoder 42 and a quantum decoder 44. Analogously to the AE 20, in the QAE 40 the quantum encoder 42 compresses the input quantum data (rho) to output a compressed latent representation matrix (may be referred to as a compressed latent representation) and the decoder 44 decodes the compressed latent representation to generate a reconstructed input. It will be appreciated that the output of the quantum encoder 42 includes the compressed latent representation and also trash qubits. The trash qubits are indicated by the measurement symbols in Figure 3 - these qubits are not needed, due to the compression by the quantum encoder from the higher-dimensional input to the lower-dimensional output. Although indicated by measurement symbols, in practice the trash qubits may be in general traced out or ignored. The quantum decoder’s 44 inputs include the compressed latent representation and ancilla qubits indicated by |0>, due to the difference in dimension between the compressed latent representation and the reconstructed input.

[0036] A specific implementation example of a quantum encoder and a quantum decoder including the structure of the QML models is described later.

[0037] The QAE 40 is able to compress quantum data of n-qubits into a condensed quantum latent space with dimensions of d-qubits (where d<n). Similarly to a classical autoencoder (e.g. the autoencoder 20), QAEs (e.g. the QAE 40) lack generative capability. In contrast with the classical regime in which a variational autoencoder (e.g. the variational autoencoder 30) allows sampling from the latent space to give rise to generative capability, there currently exist no procedures for sampling from the latent space of a QAE.

[0038] Figure 4 is a schematic diagram illustrating a generative adversarial network (GAN) 50 according to a comparative example. The GAN 50 is a classical ML model for implementation on classical hardware. The GAN 50 comprises a generator 56 and a discriminator 58. In training, the generator 56 and discriminator 58 may be considered to play a two-player game. That is, the generator 56 takes in random values sampled from a normal distribution (z) and produces, using the generator function G, synthetic samples (x’) whilst the discriminator 58 tries to distinguish between real samples (x) and generated samples (x’), using the discriminator function D. The generator 56 is trained to produce realistic output that can fool the discriminator 58, while the discriminator 58 is trained to correctly distinguish between the real and generated data.

[0039] GAN architecture has been extended to the quantum regime (i.e. for implementation on quantum hardware) and the corresponding QML model is called a Quantum GAN (QGAN). In principle, QGANs work and are trained in the same way as classical GANs. A specific implementation example of a QGAN including the structure of the QML model is described later.

[0040] Figure 5 is a schematic diagram illustrating how QML models are trained and used according to methodologies disclosed herein. Two stages of training (stage 1 and stage 2) are shown on the left-hand side of Figure 5, and a generation stage is shown on the right-hand side of Figure 5.

[0041] In training stage 1, as shown in Figure 5, a QAE (comprising a quantum encoder 62 and a quantum decoder 64) is trained according to a QAE training process. The quantum encoder 62 takes in quantum data (structured as matrices) and outputs compressed latent representation matrices (may be referred to as compressed latent representations) of / corresponding to the quantum data. This is indicated in the Figure as “compressed quantum latent space” 601. The quantum decoder 64 decodes the compressed latent representations and outputs reconstructed quantum data. A reconstruction loss is computed based on the quantum data and the reconstructed quantum data and weights of the QAE are adjusted. This training loop is iterated until loss convergence and / or for a given number of iterations.

[0042] The “trash space” 602 in Figure 5 indicates that at least one qubit output from the quantum encoder 62 is not used because the quantum data has been compressed to fewer qubits, and that at least one ancilla qubit is needed for the quantum decoder 64 to decode the compressed latent representation and output a matrix with at least one more qubit than the compressed latent representation. A more detailed implementation of a QAE training process is described later.

[0043] In training stage 2, as shown in Figure 5, a QGAN (comprising a quantum generator 66 and a quantum discriminator 68) is trained according to a QGAN training process (may be referred to as quantum adversarial training). The quantum generator 66 generates synthetic compressed latent representation matrices (may be referred to as synthetic compressed latent representations). The quantum discriminator 68 receives as input the synthetic compressed latent representations and compressed latent representations generated by the trained quantum encoder 62 (i.e. the quantum encoder 62 that has been trained according to the QAE training process). The quantum discriminator generates predictions indicating whether each of the compressed latent representations and synthetic compressed latent representations is “real” or “fake / synthetic” - i.e. whether each of the input matrices has been generated by the quantum encoder 62 or by the quantum generator 66.

[0044] The weights of the QGAN are adjusted based on the predictions by the quantum discriminator 68, i.e. based on the correctness of those predictions. Specifically, a loss is computed based on the correctness of the predictions by the quantum discriminator 68 and iterations in which the quantum discriminator 68 makes predictions are carried out until the loss converges and / or for a given number of iterations. A QGAN training process is described later with respect to Figure 9 and that description is also applicable here and vice versa.

[0045] The quantum generator 66 generates its output based on noise sampled from a distribution, referred to as entropy in the Figure. As described later, the data (quantum data) used for training the QAE, the data (quantum data) used for training the QGAN, and the entropy source (the distribution from which noise is sampled) may be chosen according to an intended application of the quantum generator 66 once trained. In some applications, the distribution is labelled and “noise” is sampled from the labelled distribution to obtain parameters according to which the quantum generator generates its output, as described later. In the generation stage, as shown in Figure 5, the trained quantum generator 66 is used to generate a synthetic compressed latent representation based on noise sampled from a distribution (entropy source), and the trained quantum decoder 64 is used to decode the synthetic compressed latent representation to generate synthetic quantum data. The sampling from a distribution (entropy) is not essential, as is described in more detail below. A synthetic compressed latent representation generated in the generation stage may be referred to as a target compressed latent representation and synthetic quantum data generated in the generation stage may be referred to as target quantum data or at least one target quantum state. In general, a quantum state is a density matrix whose values entirely characterize a quantum state. The “ancilla space” 603 indicates that the generated quantum data is higherdimensional than the synthetic compressed latent representation.

[0046] According to the methodology demonstrated by Figure 5, the QGAN is trained to learn the compressed quantum latent space of the QAE and the quantum generator 66 is thus able to generate matrices in the compressed quantum latent space, which can then be decoded by the quantum decoder 64 to generate quantum data. Training a QGAN to learn a compressed quantum latent space rather than learning the (non-compressed) distribution of the original quantum data is more efficient and leads to better synthetic quantum data generation, as is demonstrated later herein according to experiments. The methodology disclosed herein therefore overcomes the problems of QAEs not having generative capability discussed in relation to Figure 3.

[0047] The quantum encoder 62, the quantum decoder 64, the quantum generator 66 and the quantum discriminator 68 are trainable quantum unitary operators.

[0048] Methods disclosed herein include methods corresponding to the first and second training stages and the generation stage, methods corresponding to the first and second training stages, methods corresponding the second training stage and the generation stage, methods corresponding to just the second training stage, and methods corresponding to just the generation stage.

[0049] Figure 6 is a schematic diagram illustrating a specific implementation of a QAE 70. That is, Figure 6 is a schematic diagram illustrating a parameterized quantum circuit (PQC) structure for implementing the QAE 70. This PQC structure is merely an example and many alternative structures exist for implementing a QAE. The QAEs referred to elsewhere herein may be implemented according to the PQC structure illustrated in Figure 6 or any other suitable structure. The QAE 70 comprises quantum encoder 72 and quantum decoder 74. The quantum encoder PQC 72 comprises gates Rx. The gates Rxare rotation operators (for a rotation around an x-axis). Each rotation operator Rxis parametrized by a weight <|) which dictates the rotation angle of the operator. The quantum encoder 72 is said to be parametrized by a parameter which is a vector of the weights <|) parametrizing the gates Rx. That is, the gate 0 (top left gate in the Figure) is parametrized by the weight <|) [0] as indicated in the Figure, and so on and so forth for the other gates.

[0050] Quantum data is input as shown on the left-hand side of the Figure. The data is input in the form of qubits. Here there are four qubits, q0- qv The gates Rxperform operations on the qubits as shown in the Figure. The notation for the gate 4 (parametrized by <|) [4]), for example, indicates that the operator is conditioned on the qubit qo (after the operation of gate 0) and applied on the qubit qi (after the operation of gate 1). The quantum encoder PQC 72 also comprises a barrier operation 722.

[0051] The output of the quantum encoder is a compressed latent representation matrix, which is indicated in the Figure by the compressed quantum latent space 101. Because the input quantum data (4 qubits) is compressed to a 1 -qubit representation, the other qubits are not needed (indicated by “Trace out” in the Figure).

[0052] The quantum decoder PQC 74 comprises gates Rx. The structure of the quantum decoder PQC in this implementation is the same as the structure of the quantum encoder PQC (though this is not always the case) and description is omitted for brevity. It is noted that the quantum decoder PQC 74 is parametrized by a parameter The quantum decoder 74 decodes the compressed latent representation output by the quantum encoder 72 and generates reconstructed quantum data. Because the compressed latent representation is 1 -qubit and the reconstructed quantum data is 4 qubits, the quantum decoder 74 utilizes ancilla qubits indicated by |0> in the input. The ancilla qubits and the unused qubits are referred to collectively as trash space 102. The weights (i.e. the values <|) and 0 in the parameter vectors ®) are adjusted during training of the QAE.

[0053] Figure 7 is a schematic diagram illustrating a specific implementation of QGAN 80. That is, Figure 7 is a schematic diagram illustrating a PQC structure for implementing the QGAN 80. This PQC structure is merely an example and many alternative structures exist for implementing a QGAN. The QGANs referred to elsewhere herein may be implemented according to the PQC structure illustrated in Figure 7 or any other suitable structure. The QGAN 80 comprises quantum generator 86 and quantum discriminator 88.

[0054] The quantum generator PQC 85 comprises gates R (including gates Rx and gates Ry). The description of the gates Rx in Figure 6 applies here and duplicate description is omitted. The gates Ry operate similarly but with rotation around a y-axis. It is noted that the quantum generator PQC 86 is parametrized by a parameter That is, the gates R are parametrized by weights w (the values of the vector «). The gate in the quantum generator PQC 85 indicated in Figure 7 by a plus (+) is a c-not (control-not) operator and is conditioned on the value of the “top” qubit in the Figure and applied on the “bottom” qubit.

[0055] The quantum discriminator PQC 88 comprises gates R (including gates Rx and gates Ry) and a c-not gate. The description of the gates R in the quantum generator PQC 86 applies here and duplicate description is omitted. It is noted that the quantum discriminator PQC 88 is parametrized by a parameter That is, the gates R are parametrized by weights a (the values of the vector «■ ).

[0056] The QGAN PQC 80 comprises a structure 81 for sampling entropy. The structure 81 comprises gates Ry (rotation operator for rotation around y-axis) and Rz (rotation operator for rotation around z-axis), parametrized by P[0] and P[l], respectively. The weights P are sample from a distribution. For example, the weights may be sampled from a probability distribution p(P | r) conditioned on a parameter r with probability p(r). Ancilla qubits denoted by |0> are input and entropy is injected by the structure 81, and the qubits are fed to the quantum generator PQC 86. In other words, the weights P may be considered the entropy, or the “noise” sampled from a distribution. As described below with respect to Figures 9 and 10, entropy injection is not essential. For example, labelled information may be provided / inj ected .

[0057] Figure 8 is a flowchart illustrating a method for training a QAE, e.g. the QAE in Figure 3 and / or the QAE in Figure 5 and / or the QAE in Figure 6. The Figure 8 method may be referred to as a QAE training process. The method comprises steps S10-S20. Step S10 comprises choosing the PQC (parametrized quantum circuit) structure of the QAE and initializing the parameters of the QAE: and . The parameters 0 and are for the quantum encoder and the quantum decoder, respectively. Each of the parameters and is a vector of values. The values may be considered analogous to weights of classical ML models. The parameters may be referred to as weights herein, even in the context of quantum computing. The structure shown in Figure 6 may be chosen as the PQC structure.

[0058] Step Si l comprises initiating the training loop of the QAE. Step S12 comprises initializing the parameters of the QAE: and (in the first iteration of training this step is not necessary as it is already completed in step S10; in subsequent iterations, this step means to initialize the parameters with the updated weights). Step S13 comprises initializing an array (e.g. an array of zeroes) for saving the values given by the cost function that will be used to compute the loss in the QAE training.

[0059] Step S14 comprises providing training data. Here, the training data is denoted i, with i = 1- N. Each instance i is a vector / matrix of values. Step S15 comprises starting a loop over i.

[0060] Step S16 comprises applying the QAE to the training data instance i. That is, step S16 comprises using the quantum encoder to generate, based on the training data instance, a compressed latent representation matrix (which may be referred to as a compressed latent representation) of / corresponding to the training data instance and using the quantum decoder to generate, based on the compressed latent representation, a reconstructed data instance. The QAE PQC may be referred to as an ansatz. An ansatz is a trial form (a “guess”) of what the solution (the trained QAE) will be. That is, the PQC is able to embody trial solutions based on different parametrizations of the PQC. In other words, the ansatz of the QAE is the PQC chosen in step S10 with the initialized weights. The parameters / weights ( and ?) in the ansatz are adjustable (as described below as part of this method). The parameters include, for example, rotation angles of the quantum gates in the quantum circuit. Herein the terms ansatz and quantum circuit or PQC may be used interchangeably before and during training of the quantum circuit concerned (for example, once e.g. the QAE has been trained, the weights therein may no longer be considered a “trial solution”). Step S16 is implemented using quantum computing hardware whilst the remaining steps may be implemented using classical computing hardware. This is indicated by the double line around step S16. Step S16 may be implemented as control (by classical hardware) of quantum hardware to implement the quantum circuit.

[0061] Step S17 comprises evaluating the cost function based on the output of the quantum decoder and the training instance. The cost function in this implementation is the fidelity, which indicates how close / similar the reconstructed quantum data is to the training data. The result of evaluating the cost function for i is added to the array defined for saving the cost function results. Steps S16 and S17 are repeated for each i so that the array defined in step S13 includes the results of evaluating the cost function for each i (1-N).

[0062] Step S18 comprises computing the global cost function. For example, the global cost function may comprise summing the result of the cost function for each i, contained in the array initialized in step S13. Although as described above an array is defined and cost function results are added thereto, alternatively the cost function results may simply be summed without the need for an array.

[0063] Also in step SI 8, it is determined whether or not the cost / loss has converged. If not, the method proceeds to step S19 where the parameters and 0 are updated (for example using an optimizer such as Adam optimizer (Diederik P. Kingma, Jimmy Ba: “Adam: A Method for Stochastic Optimization”, arxiv.org / abs / 1412.6980)). The steps S13-S18 are then repeated (for a different batch of the training data or for the same training data) until it is determined that the cost / loss has converged.

[0064] If it is determined that the cost / loss has converged, the method proceeds to step S20 in which the parameters are fixed / output as The output of the Figure 8 method is thus the trained parameters, i.e. the trained QAE.

[0065] The Figure 8 method may be considered to correspond to training stage 1 in Figure 5. Figure 9 is a flowchart illustrating a method for training a QGAN, e.g. the QGAN in Figure 5 and / or the QGAN in Figure 7. The Figure 9 method may be referred to as a QGAN training process. The method comprises steps S30-S37, steps S40-S46, and steps S50-58.

[0066] Step S30 comprises choosing the PQC (parametrized quantum circuit) structure of the QGAN and initializing the parameters of the QGAN: and . The parameters and are for the quantum generator and the quantum discriminator, respectively. Each of the parameters « and « is a vector of values. The values may be considered analogous to weights of classical ML models. The parameters may be referred to as weights herein, even in the context of quantum computing. The structure shown in Figure 7 may be chosen as the PQC structure.

[0067] Step S31 comprises initiating the training loop of the QGAN. Step S32 comprises initializing the parameters of the QGAN: and (in the first iteration of training this step is not necessary as it is already completed in step S30; in subsequent iterations, this step means to initialize the parameters with the updated weights).

[0068] Step S33 comprises initializing an array (e.g. an array of zeroes) for saving the values given by the generator cost function that will be used to compute the cost / loss for the quantum generator in the QGAN training. Step S34 comprises initializing an array (e.g. an array of zeroes) for saving the values given by the discriminator cost function that will be used to compute the cost / loss for the quantum discriminator in the QGAN training.

[0069] The flows of steps S40-S46 and S50-S58 are for generating the inputs to the quantum discriminator, generating predictions by the quantum discriminator, and evaluating the predictions.

[0070] Step S50 comprises providing training data. Here, the training data is denoted with i = 1- N. Each instance i is a vector / matrix of values. Step S52 comprises starting a loop over i.

[0071] Step S54 comprises applying a quantum encoder (e.g. the quantum encoder trained according to the Figure 8 method) to the training data instance i. That is, step S54 comprises using the quantum encoder to generate, based on the training data instance, a compressed latent representation matrix (which may be referred to as a compressed latent representation) of / corresponding to the training data instance. Step S56 comprises applying the quantum discriminator to the compressed latent representations generated by the quantum encoder. That is, step S56 comprises using the quantum discriminator to predict whether each of the compressed latent representations is real or synthetic / fake, i.e. generated by the quantum encoder or generated by the quantum generator. Specifically, step S56 comprises applying an ansatz of the quantum discriminator to the training data instance. As mentioned above, an ansatz is a trial form (a “guess”) of what the solution (the trained quantum discriminator) will be. The parameters / weights («) in the ansatz are adjustable (as described below as part of this method). The parameters include, for example, rotation angles of the quantum gates in the quantum circuit.

[0072] Step S58 comprises evaluating the discriminator cost function based on the output of the quantum discriminator and the truth (which is that the compressed latent representations input in step S56 are “real”). The cost function may comprise computation of a trace distance (e.g. between the real quantum state and the synthetic quantum state). The result of evaluating the cost function for i is added to the array defined for saving the cost function results. Steps S54- S58 are repeated for each i so that the array defined in step S34 includes the results of evaluating the discriminant cost function for each i (1-N).

[0073] Step S40 comprises injecting entropy to the quantum generator. In other words, step S40 may be considered to comprise choosing a distribution from which to sample (and sampling therefrom). As shown in step S42, the ansatz of the quantum generator includes “entropy source”. This may be understood with reference to Figure 7 which shows the quantum generator PQC 86 and the structure 81 - the structure 81 may be considered an entropy source and the ansatz of the quantum generator may be considered to include the entropy source. Weights in the entropy source (in the structure 81) determine the sampling as described above.

[0074] Although the step S40 (inject entropy) is shown in Figure 9, this step is not essential. The use-case for the models being trained do not necessarily require entropy injection during the training. The step S40 may be considered, with respect to some use cases, to comprise injecting labelled information. For example, the training data may include quantum states characterized by a value of one or more parameters, and the labelled information may comprise the values of the one or more parameters for the training data. For instance, in example 2 described below, the training data (and the data to be generated) comprises ground states of a hydrogen molecule each characterized by an interatomic distance - in this case the interatomic distance value is the label or labelled information. The labelled information in such cases may be considered parameters or constraints.

[0075] Step S42 comprises using the quantum generator to generate synthetic (or auxiliary) compressed latent representations based on the sampled noise (entropy source). Specifically, an ansatz is used, similarly to as described above for the quantum discriminator.

[0076] Step S44 comprises applying the quantum discriminator to the synthetic compressed latent representations generated by the quantum generator. That is, step S44 comprises using the quantum discriminator to predict whether each of the synthetic compressed latent representations is real or synthetic / fake, i.e. generated by the quantum encoder or generated by the quantum generator. Specifically, step S44 comprises applying an ansatz of the quantum discriminator, as described with respect to step S56.

[0077] Step S46 comprises evaluating the generator cost function and the discriminator cost function based on the output of the quantum discriminator in step S44 and the truth (which is that the synthetic compressed latent representations input in step S44 are “synthetic”). The cost function may comprise computation of a trace distance between the compressed latent representations and the synthetic compressed latent representations. The result of evaluating the generator cost function is added to the array defined for saving the generator cost function results and the result of evaluating the discriminator cost function is added to the array defined for saving the discriminator cost function results.

[0078] Considering the generator cost function in principle, the quantum generator is penalized for generating synthetic compressed auxiliary representations that the quantum discriminator successfully determines to be synthetic, and considering the discriminator cost function in principle, the quantum discriminator is penalized for incorrectly predicting whether a compressed latent representation or a synthetic compressed latent representation is “real” or “synthetic”.

[0079] Step S35 comprises computing the global cost function based on the results of the discriminator cost function and of the generator cost function. For example, the results in each array may be summed and the resulting two values may be summed. Although as described above an array is defined for each cost function and cost function results are added thereto, alternatively the cost function results may simply be summed without the need for an array. Furthermore, although as described above two separate cost functions are used, a single cost function may be used.

[0080] Also in step S35, it is determined whether or not the cost / loss has converged. If not, the method proceeds to step S36 where the parameters « and ® are updated (for example using an optimizer such as Adam optimizer). The steps S33-S58 are then repeated (for the same batch of training data or a different batch of training data) in the same way as described above until it is determined that the cost / loss has converged.

[0081] If it is determined that the cost / loss has converged, the method proceeds to step S37 in which the parameters are fixed / output as The output of the Figure 9 method is thus the trained parameters, i.e. the trained QGAN.

[0082] Steps S40-S44, S54, and S56 are implemented using quantum computing hardware whilst the remaining steps may be implemented using classical computing hardware. This is indicated by the double line around steps S40-S44, S54, and S56. Steps S40-S44, S54, and S56 may be implemented as control (by classical hardware) of quantum hardware to implement the quantum circuit.

[0083] In an implementation of the Figure 9 method, in one iteration N synthetic compressed latent representations are generated - the same number as the number of compressed latent representations generated by the quantum encoder. However, any number may be generated in any iteration.

[0084] The method may comprise a first phase comprising at least one iteration in which weights of the quantum generator are frozen and weights of the quantum discriminator are adjusted and at least a second phase comprising at least one iteration in which weights of the quantum discriminator are frozen and weights of the quantum generator are adjusted. Such first and second phases may be alternated. Each first phase may comprise a first number of iterations (e.g. 10) and each second phase may comprise a second number of iterations (e.g. 1), or the instances of the phases may comprise any other number of iterations. The Figure 9 method may be considered to correspond to training stage 2 in Figure 5.

[0085] In the methods described with respect to Figures 8 and 9 loss convergence is used to determine whether training is complete. An alternative or additional threshold for determining whether training is complete may comprises checking whether a threshold number of iterations has been performed.

[0086] Figure 10 is a flowchart illustrating a method for generating quantum data, i.e. quantum states. The method comprises steps S60-S66.

[0087] Step S60 comprises starting the generating loop. Step S62 comprises initializing the trained parameters and itrsw of the trained QAE and the trained QGAN.

[0088] Step S64 comprises injecting entropy - that is, sampling noise from a distribution. Step S66 comprises using a quantum circuit, comprising the trained quantum generator and the trained quantum decoder, to generate data, e.g. quantum state(s) indicated in Figure 10 as The quantum generator is a quantum generator that has been trained according to the QGAN training process described with respect to Figure 5 and / or Figure 9, and the quantum decoder is a quantum decoder that has been trained according to the QAE training process described with respect to Figure 5 and / or Figure 8. Step S66 comprises generating, using the quantum generator and based on the sampled noise (entropy), a target compressed latent representation matrix (which may be referred to as a target compressed latent representation), and decoding, using the quantum decoder, the target compressed latent representation to generate at least one target quantum state. Entropy may be injected by sampling from a distribution, e.g. according to the weights P[l] and P[2], The step S64 may be considered to comprise injecting / providing labelled information instead of (or in addition to) injecting entropy, similarly as described above with respect to Figure 9.

[0089] It is described below how using particular training data in the QAE training process and in the QGAN training process leads to a quantum circuit (quantum generator + quantum decoder) which is able to generate desired target quantum states, and worked examples with specific data are described. Steps S64-S66 are implemented using quantum computing hardware whilst the remaining steps may be implemented using classical computing hardware. This is indicated by the double line around steps S64-S66. Steps S64-S66 may be implemented as control (by classical hardware) of quantum hardware to implement the quantum circuit.

[0090] Figure 11 is a flowchart illustrating a method comprising steps S70-S78. Steps S70-S78 are for training a QGAN, e.g. the QGAN in Figure 5 and / or the QGAN in Figure 7, and may be referred to as a QGAN training process. The Figure 11 method may be referred to as a QGAN training process.

[0091] Step S70 comprises generating, using a quantum encoder, compressed latent representations based on training data. That is, step S70 comprises generating, using a (trained) quantum encoder and based on (first) training (quantum) data, compressed latent representations (matrices / vectors) of / corre spending to the (first) training (quantum) data.

[0092] Step S72 comprises generating, using a quantum generator, synthetic compressed latent representations. That is, step S72 comprises generating, using the quantum generator, synthetic compressed latent representations (matrices / vectors).

[0093] Step S74 comprises generating, using a quantum discriminator, predictions indicating whether inputs are real or synthetically generated. That is, step S74 comprises generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator.

[0094] Step S78 comprises adjusting QGAN weights. That is, step S78 comprises adjusting, based on the (correctness of the) predictions, weights / parameters of the QGAN.

[0095] In line with Figure 11, for example, and according to a first embodiment there is disclosed herein a computer-implemented method comprising training a quantum generative adversarial network, QGAN, comprising a quantum generator and a quantum discriminator, according to a QGAN training process comprising (performing adversarial training by): generating, using a (trained) quantum encoder and based on (first) training (quantum) data, compressed latent representations (matrices / vectors) of / corre spending to the (first) training (quantum) data; generating, using the quantum generator, synthetic compressed latent representations (matrices / vectors); generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the (correctness of the) predictions, weights / parameters of the QGAN.

[0096] Adjusting the weights of the QGAN may comprise computing a loss based on the (correctness of the) predictions generated by the quantum discriminator.

[0097] Computing the loss may comprise computing a trace distance (between the compressed latent representations and the synthetic compressed latent representations).

[0098] Computing the loss may comprise computing a generator loss based on whether the quantum discriminator’s predictions relating to the synthetic compressed latent representations are correct and computing a discriminator loss based on whether the quantum discriminator’s predictions relating to the synthetic compressed latent representations and the compressed latent representations are correct.

[0099] Generating, using the quantum generator, each synthetic compressed latent representation may comprise generating the synthetic compressed latent representation based on noise or parameters sampled from a distribution.

[0100] Generating, using the quantum generator, each synthetic compressed latent representation may comprise generating the synthetic compressed latent representation based on labelled information / labels / parameters .

[0101] Using the quantum encoder, the quantum generator, and the quantum discriminator may comprise controlling a parametrized quantum circuit, PQC, implementing the quantum encoder, controlling a PQC implementing the quantum generator, and controlling a PQC implementing the quantum discriminator, respectively. The computer-implemented method may comprise, before performing the QGAN training process, training a quantum autoencoder, QAE, comprising the quantum encoder and a quantum decoder by performing a QAE training process comprising: generating, using the quantum encoder and based on an instance of (second) training (quantum) data, a compressed latent representation (matrix / vector) of / corresponding to the instance of (second) training (quantum) data; decoding, using the quantum decoder, the compressed latent representation (matrix / vector) to generate a reconstructed instance; computing a reconstruction loss based on (between) the instance of (second) training (quantum) data and the reconstructed instance; and adjusting, based on the reconstruction loss, at least one weight / parameter of the QAE.

[0102] The (first) training data for use in the quantum encoder training process may be the same as the (second) training data for use in the QGAN training process or the (first) training data for use in the quantum encoder training process and / or the (second) training data for use in the QGAN training process may share at least one property.

[0103] Using the quantum decoder may comprise controlling a PQC implementing the quantum decoder.

[0104] The QGAN training process may comprise a number of iterations, each iteration comprising: generating, using the quantum encoder, at least one compressed latent representation and / or generating, using the quantum generator, at least one synthetic compressed latent representation; generating, using the quantum discriminator, at least one prediction indicating whether the at least one compressed latent representation and / or the at least one synthetic compressed latent representation has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the (correctness of the) at least one prediction, weights of the QGAN.

[0105] The QGAN training process may comprise iterating the steps of generating the compressed latent representations, generating the synthetic compressed latent representations, generating the predictions, and adjusting the weights.

[0106] The QGAN training process may comprise iterating the steps of generating the compressed latent representations, generating the synthetic compressed latent representations, generating the predictions, computing the loss, and adjusting the weights. The QGAN training process may comprise iterating the steps for a threshold number of iterations and / or until loss convergence.

[0107] The QGAN training process may comprise at least a first phase in which weights of the quantum generator are frozen and weights of the quantum discriminator are adjusted and at least a second phase in which weights of the quantum discriminator are frozen and weights of the quantum generator are adjusted.

[0108] The QGAN training process may comprise at least a first phase comprising at least one iteration in which weights of the quantum generator are frozen and weights of the quantum discriminator are adjusted and at least a second phase comprising at least one iteration in which weights of the quantum discriminator are frozen and weights of the quantum generator are adjusted.

[0109] The QAE training process may comprise iterating, for each of a plurality of instances of the (second) training (quantum) data, the steps of generating a compressed latent representation of the instance of training data, decoding the compressed latent representation, computing a reconstruction loss, and adjusting at least one weight of the encoder.

[0110] The QAE training process may comprise iterating the steps for a threshold number of iterations and / or until loss convergence and / or until the computed reconstruction loss meets a reconstruction loss threshold.

[0111] The (first and / or second) training data may comprise quantum states with entanglement entropy above an entropy threshold and the computer-implemented method may comprise, after performing the QGAN training process, generating at least one new quantum state with an entanglement entropy above the entropy threshold by generating, using the quantum generator, a (target) synthetic compressed latent representation (matrix / vector) and decoding, using a / the quantum decoder, the (target) synthetic compressed latent representation (matrix / vector) to generate the at least one new quantum state.

[0112] The (first and / or second) training data may comprise ground states of at least one molecule and the computer-implemented method may comprise, after performing the QGAN training process, generating at least one new ground state of the at least one molecule by generating, using the quantum generator, a (target) synthetic compressed latent representation (matrix / vector) and decoding, using a / the quantum decoder, the (target) synthetic compressed latent representation (matrix / vector) to generate the at least one new ground state.

[0113] The computer-implemented method may comprise, after performing the QGAN training process: generating, using the quantum generator, a target compressed latent representation (matrix / vector); and decoding, using a / the quantum decoder, the target compressed latent representation (matrix / vector) to generate at least one target quantum state.

[0114] The at least one target quantum state and the (first and / or second) training data may share at least one property.

[0115] Each quantum state in the (first and second) training data may correspond to and be labelled according to a value of a property, and generating the target compressed latent representation may comprise generating the target compressed latent representation based on a value of the property different from the values among the (first and second) training data.

[0116] In the QGAN training process, each synthetic compressed latent representation may be generated according to a value of the property (via labelled information provided to the quantum generator), and the adversarial loss may be computed based on pairs each comprising a synthetic compressed latent representation and a compressed latent representation which correspond to the same value of the property.

[0117] The (first and second) training data may comprise quantum states with entanglement entropy above an entropy threshold and the at least one target quantum state may have (may be generated so as to emulate a quantum state which has) an entanglement entropy above the entropy threshold (and is not in the training data).

[0118] The (first and second) training data may comprise 2-qubitqubit quantum states; the quantum encoder may be configured to generate 1 -qubitqubit compressed latent representations; the quantum generator may be configured to generate 1 -qubitqubit compressed latent representations; and the quantum decoder may be configured to decode 1 -qubitqubit latent representations into 2-qubitqubit quantum states. The (first and second) training data may comprise ground states of at least one molecule and the at least one target quantum state may be (may be generated so as to emulate a quantum state which is) a ground state of the at least one molecule (which is not in the training data).

[0119] The (first and second) training data may comprise 4-qubitqubit quantum states; the quantum encoder may be configured to generate 1 -qubitqubit compressed latent representations; the quantum generator may be configured to generate 1 -qubitqubit compressed latent representations; and the quantum decoder may be configured to decode 1 -qubitqubit latent representations into 4-qubitqubit quantum states.

[0120] The QGAN may be a conditional QGAN.

[0121] The at least one property may be that each quantum state has an entanglement entropy above an entropy threshold or that each quantum state is a ground state of a molecule.

[0122] Each of the ground states in the (first and second) training data may correspond to and be labelled according to an interatomic distance, and generating the target compressed latent representation may comprise generating the target compressed latent representation based on an interatomic distance not present among the (first and second) training data.

[0123] In the QGAN training process, each synthetic compressed latent representation may be generated according to an interatomic distance, and the adversarial loss may be computed based on pairs each comprising a synthetic compressed latent representation and a compressed latent representation which correspond to the same interatomic distance.

[0124] The computer-implemented method may comprise using quantum hardware and non- quantum / classical hardware to implement the computer-implemented method.

[0125] The computer-implemented method may comprise using quantum hardware to implement the quantum encoder, the quantum decoder, the quantum generator, and the quantum discriminator, and using non-quantum / classical hardware to implement at least one other step of the computer-implemented method. According to a second embodiment there is disclosed herein a computer program which, when run on a computer, causes the computer to carry out a method comprising (performing adversarial training by): generating, using a (trained) quantum encoder and based on (first) training (quantum) data, compressed latent representations (matrices / vectors) of / corresponding to the (first) training (quantum) data; generating, using the quantum generator, synthetic compressed latent representations (matrices / vectors); generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the (correctness of the) predictions, weights / parameters of the QGAN.

[0126] According to a third embodiment there is disclosed herein an information processing apparatus comprising a memory and a processor connected to the memory, wherein the processor is configured to carry out a QGAN training process comprising (performing adversarial training by): generating, using a (trained) quantum encoder and based on (first) training (quantum) data, compressed latent representations (matrices / vectors) of / corresponding to the (first) training (quantum) data; generating, using the quantum generator, synthetic compressed latent representations (matrices / vectors); generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the (correctness of the) predictions, weights / parameters of the QGAN.

[0127] The information processing apparatus may comprise at least one quantum (arithmetic) processor to implement the quantum encoder, (the quantum decoder,) the quantum generator, and the quantum discriminator.

[0128] The processor may be configured to control the at least one quantum processor to use the quantum encoder, (the quantum decoder,) the quantum generator, and the quantum discriminator.

[0129] The processor may comprise at least one quantum (arithmetic) processor to implement the quantum encoder, (the quantum decoder,) the quantum generator, and the quantum discriminator. According to a fourth embodiment there is disclosed herein a computer-implemented method comprising: generating, using a quantum generator, a compressed latent representation (matrix / vector); and decoding, using a quantum decoder, the compressed latent representation (matrix / vector) to generate at least one target quantum state, wherein the quantum generator has been trained as part of a QGAN training process for training a quantum generative adversarial network, QGAN, comprising the quantum generator and a quantum discriminator, to generate synthetic compressed latent representations (matrices / vectors) emulating compressed latent representations (matrices / vectors) generated by a quantum encoder as applied to training (quantum) data, wherein the training (quantum) data and the target at least one quantum state share at least one property.

[0130] The (first and / or second) training data may comprise quantum states with entanglement entropy above an entropy threshold.

[0131] The at least one property shared by the training data and the at least one quantum state may be that each quantum state has an entanglement entropy above an entropy threshold.

[0132] The (first and / or second) training data may comprise ground states of at least one molecule.

[0133] The at least one property shared by the training data and the at least one quantum state may be that each quantum state is a ground state of at least one molecule.

[0134] Each quantum state in the (first and second) training data may correspond to and be labelled according to a value of a property, and generating the target compressed latent representation may comprise generating the target compressed latent representation based on a value of the property different from the values among the (first and second) training data.

[0135] The (first and second) training data may comprise quantum states with entanglement entropy above an entropy threshold and the at least one target quantum state may have (may be generated so as to emulate a quantum state which has) an entanglement entropy above the entropy threshold (and is not in the training data). The (first and second) training data may comprise 2-qubitqubit quantum states; the quantum encoder may be configured to generate 1 -qubitqubit compressed latent representations; the quantum generator may be configured to generate 1 -qubitqubit compressed latent representations; and the quantum decoder may be configured to decode 1 -qubit latent representations into 2-qubit quantum states.

[0136] The (first and second) training data may comprise ground states of at least one molecule and the at least one target quantum state may be (may be generated so as to emulate a quantum state which is) a ground state of the at least one molecule (which is not in the training data).

[0137] The (first and second) training data may comprise 4-qubit quantum states; the quantum encoder may be configured to generate 1 -qubit compressed latent representations; the quantum generator may be configured to generate 1 -qubit compressed latent representations; and the quantum decoder may be configured to decode 1 -qubit latent representations into 4- qubit quantum states.

[0138] The QGAN may be a conditional QGAN.

[0139] Each of the ground states in the (first and second) training data may correspond to and be labelled according to an interatomic distance, and generating the target compressed latent representation may comprise generating the target compressed latent representation based on an interatomic distance not present among the (first and second) training data.

[0140] According to a fifth embodiment there is disclosed herein a computer program which, when run on a computer, causes the computer to carry out a method comprising: generating, using a quantum generator, a compressed latent representation (matrix / vector); and decoding, using a quantum decoder, the compressed latent representation (matrix / vector) to generate at least one target quantum state, wherein the quantum generator has been trained as part of a QGAN training process for training a quantum generative adversarial network, QGAN, comprising the quantum generator and a quantum discriminator, to generate synthetic compressed latent representations (matrices / vectors) emulating compressed latent representations (matrice s / vectors) generated by a quantum encoder as applied to training (quantum) data, wherein the training (quantum) data and the target at least one quantum state share at least one property. According to a sixth embodiment there is disclosed herein an information processing apparatus comprising a memory and a processor connected to the memory, wherein the processor is configured to: generate, using a quantum generator, a compressed latent representation (matrix / vector); and decode, using a quantum decoder, the compressed latent representation (matrix / vector) to generate at least one target quantum state, wherein the quantum generator has been trained as part of a QGAN training process for training a quantum generative adversarial network, QGAN, comprising the quantum generator and a quantum discriminator, to generate synthetic compressed latent representations (matrices / vectors) emulating compressed latent representations (matrices / vectors) generated by a quantum encoder as applied to training (quantum) data, wherein the training (quantum) data and the target at least one quantum state share at least one property.

[0141] The information processing apparatus may comprise at least one quantum (arithmetic) processor to implement the quantum decoder and the quantum generator.

[0142] The processor may be configured to control the at least one quantum processor to use the quantum decoder and the quantum generator.

[0143] The processor may comprise at least one quantum (arithmetic) processor to implement the quantum decoder and the quantum generator.

[0144] Features of any embodiment may be applied to any other embodiment.

[0145] Steps S70-S78 (or S70-S74) may be implemented as control (by classical hardware) of quantum hardware to implement the quantum circuit. That is, steps involving using a quantum ML model may be implemented as control (by classical hardware) of quantum hardware to implement the quantum ML model (i.e. control of a quantum circuit implementing the quantum ML model to carry out the method step).

[0146] Figure 12 is a flowchart illustrating a method comprising steps S170-S182. Steps S170-S174 are the same as steps S70-S74 in Figure 11 and corresponding description applies. Step S176 comprises determining whether training of the QGAN is complete, for example based on whether error convergence has occurred or whether an error / loss threshold has been met or whether a threshold number of iterations has been carried out. If no, the method proceeds to step SI 78 which comprises adjusting weights of the QGAN, and then the method proceeds to step S170 for another iteration (based on further training data). If yes, the method proceeds to step SI 80 which comprises generating, using the quantum generator, a target compressed latent representation. Step SI 82 comprises decoding, using the quantum decoder, the target compressed latent representation to generate at least one target quantum state. Description with respect to Figure 11 relating to the target compressed latent representation and the at least one target quantum state is applicable here also.

[0147] An example application (example 1) of the proposed methodology will now be described - the generation of quantum states with entanglement entropy above a threshold (e.g. an entanglement threshold). In example 1, a parametrized quantum circuit (with trainable parameters) implementing a quantum generator and a quantum decoder is trained in line with the description above. No labelling is required in this example with regards to the injection of entropy. That is, the entropy during the training and during the generating stage is sampled from an unlabeled distribution.

[0148] Whilst it is described above that no labelling is required in this example in the sense that the entropy is sampled from an unlabeled distribution, it is noted that weights / parameters of the quantum circuits defined herein may also be considered “entropy” or “labels”. For example, the weights / parameters may be considered labels, upon which the generation of quantum states is conditioned. Furthermore, the weights / parameters may be (initially) sampled from a distribution, or in other words an “entropy source” (e.g. a Haar random sampling protocol may be used). The weights / parameters may be defined so that one / some is / are defined as labels and one / some is / are sampled from a distribution or entropy source.

[0149] A QAE was trained in line with the above QAE training process using, as the training data, 2- qubit quantum states with entanglement entropy above 97%. These states were compressed to 1 -qubit latent representations. A QGAN was trained in line with the above QGAN training process using the same training data - that is, the QGAN learned the 1 -qubit compressed latent representation space. In other words, the trained quantum encoder compressed the 2- qubit states to generate 1 -qubit latent representations and the quantum generator was trained to generate 1 -qubit compressed latent representations that the quantum discriminator was unable to distinguish from the output of the quantum encoder (and also the quantum discriminator was trained to improve its ability to distinguish between the two inputs).

[0150] The trained quantum generator and quantum decoder were then used to generate new 2-qubit quantum states (the quantum generator was used to generate 1 -qubit synthetic compressed latent representations and the quantum decoder was used to decode these to generate “target” quantum states). For injecting entropy during the training and during the generating the same distribution was sampled from. Circuit structure 81 in Figure 7 was used as the specific implementation of the entropy source to generate the 2-qubit states of interest for this example. 10000 quantum states were generated, and of these 5945 were valid (entanglement entropy above 97%), and all of those 5945 valid states were novel, i.e. not present in the training data (because new parameters P[0] and P[l] were sampled each time as entropy injection for each generated state), and the minimum entanglement entropy of the generated states was 86.47%. Thus, the quantum circuit was able to generate new 2-qubit quantum states up to an accuracy of 59.45%.

[0151] Another example application (example 2) of the proposed methodology will now be described - the generation of ground states of a parametrized Hamiltonian, in this case for a hydrogen molecule. The quantum states considered in this example (those in the training data and the generated states) are ground states of the Hydrogen Molecule at different values of interatomic distance (r). A given value of r corresponds to a unique molecular configuration of the two hydrogen atoms, and the corresponding ground state has the lowest electronic energy forthat configuration.

[0152] A parametrized quantum circuit, with trainable parameters, implementing a quantum generator and a quantum decoder is trained in line with the above description and used to generate ground states of the Hamiltonian. This example uses conditioned labelling for generation of quantum states - that is, the label information is encoded in the quantum circuit and, conditioned on that labelled information, quantum states are generated. No prior distribution is used in this case as an “entropy source”. That is, in this example there is no “randomness” needing to be sampled from a distribution. Referring to Figure 7 or Figure 9, it may be understood that the “entropy” in those Figures is instead label information. In example 2 the labels are interatomic distances in a hydrogen molecule. Because the generation by the QGAN in this example is conditioned on labeled information, it is referred to as a conditional QGAN, and may be considered, by virtue of the training using labelled information, as having the labels as parameters (in addition to the trainable parameters which are adjusted during the training). In other words, the interatomic distance is encoded as a variational parameter in the QGAN.

[0153] A QAE was trained in line with the above QAE training process using, as the training data, a set of ground states (each represented by 4-qubits) corresponding to the different interatomic distances in a Hydrogen Molecule. These states were compressed to their 1 -qubit latent representations. A QGAN was trained in line with the above QGAN training process using the same training data - that is, the QGAN learned the 1 -qubit compressed latent representation space. In other words, the trained quantum encoder compressed the 4-qubit states to generate 1 -qubit latent representations and the quantum generator was trained to generate 1 -qubit compressed latent representations that the quantum discriminator was unable to distinguish from the output of the quantum encoder (and also the quantum discriminator was trained to improve its ability to distinguish between the two inputs). As noted above, labelled information may be considered to have been injected to the quantum generator during training in the form of the interatomic distances. The interatomic distances used during the training were the interatomic distances corresponding to the states in the training data.

[0154] The trained quantum generator and quantum decoder were then used to generate new 4-qubit states (the quantum generator was used to generate 1 -qubit synthetic compressed latent representations and the quantum decoder was used to decode these to generate “target” quantum states).

[0155] Some results are illustrated in Figure 13. On the left-hand side (LHS) a graph shows with a broken line with exact energy profile of the hydrogen molecule. The crosses indicate the training data - that is, each cross indicates a ground state corresponding to an interatomic distance. Each state comprises an interatomic distance (x-axis) and a ground state energy (y- axis). The solid line represents the energy profile at various interatomic distances after training the model, and the broken line represents the exact energy profile. For completeness, it is noted that the labelled information used in the training (injected to the quantum generator during training) consisted of the interatomic distance of each of the seven ground states of the training data. It will be appreciated that the “test” solid line (corresponding to the generated states) is close to the exact energy profile.

[0156] The right-hand side (RHS) graph illustrates the fidelity of the generated ground states energy compared to the exact energy profile. Fidelity measures how close a generated ground state is to the exact ground state (in terms of the ground state energy) for a given interatomic distance. A fidelity of 1 means they are the same. It will be appreciated that the fidelity is close to 1 across the range of interatomic distances.

[0157] The size of each quantum agent (in terms of number of qubits) and the number of trainable parameters in each quantum agent in example 2 is shown below:

[0158] Encoder: 4 qubits, 16 trainable parameters

[0159] Decoder: 4 qubits, 16 trainable parameters

[0160] Generator: 1 qubit, 12 trainable parameters

[0161] Discriminator: 4 qubits, 12 trainable parameters.

[0162] Example 2 (generating ground states of a Hamiltonian) has applications in Quantum Chemistry, Quantum Sensing, Material Science, and Drug Discovery.

[0163] To evaluate the invention, the proposed methodology in the context of example 2 was compared with a comparative method: Meta-VQE (Cervera-Lierta et al. "Meta-variational quantum eigensolver: Learning energy profiles of parameterized hamiltonians for quantum simulation." PRX Quantum 2.2 (2021): 020329).

[0164] Meta-VQE is an algorithm able to learn the ground state energy profile of a parametrized Hamiltonian. By training the meta-VQE with a few data points, it delivers an initial circuit parametrization that can be used to compute the ground state energy of any parametrization of the Hamiltonian within a certain trust region.

[0165] Firstly, it is noted that according to the number of trainable parameters in each quantum agent described above, there are in total 56 trainable parameters in the proposed methodology used in example 2. In contrast, the Meta-VQE uses 64 trainable parameters. Therefore the proposed methodology has fewer trainable parameters which may result in lower processing time / load for training. The size and number of trainable parameters for each quantum agent in the Meta-VQE is shown below, for completeness.

[0166] Meta-VQE:

[0167] Encoding: 4 qubits, 48 trainable parameters Processing: 4 qubits, 16 trainable parameters.

[0168] Figure 14 illustrates some results of the comparison. The top two graphs show the results of example 2 using the proposed methodology (“QAE-QGAN”). These graphs illustrate substantially the same results as Figure 13 and duplicate description is omitted. The bottom two graphs illustrate results of using Meta-VQE to generate ground states of a hydrogen molecule. Both QAE-GQAN and Meta-VQE were trained using the same training data, the set of ground state wavefunctions of Hydrogen molecule at different interatomic distances (r=[0.4, 0.5, 0.7, 1.1, 1.5, 2.0, 2.5]). As with the above two graphs (and the Figure 13 graphs), regarding the bottom two graphs, on the LHS a graph shows with a short-dashed line the exact energy profile of the hydrogen molecule and a long-dashed line indicates the generated (synthetic) ground states, and the RHS graph illustrates the fidelity of the generated ground states compared to the exact ground states. In the bottom two graphs the interatomic distances of the training data are indicated using dots.

[0169] Figure 15 illustrates the same results as Figure 14 but with the QAE-QGAN and Meta-VQE graphs overlaid on one another. The top graph shows the energy profiles of the QAE-QGAN generated states and the Meta-VQE generated states, together with the exact energy profile, the middle graph shows the fidelity of each methodology when applied as described herein for generating hydrogen ground states, and the bottom graph shows the absolute error between the energy profile of the QAE-QGAN generated states and the exact energy profile and between the Meta-VQE generated states and the exact energy profile. In each graph, the line with crosses indicates the QAE-QGAN results and the line with dots indicates the Meta- VQE results. In the top graph the short-dashed line indicates the exact energy profile. It will be appreciated from Figures 14 and 15 that the proposed methodology (QAE-QGAN) is more accurate than the comparative method (Meta-VQE) in generating ground states, when trained on the same set of training data, in the sense that the energy profile of the generated (synthetic) states is closer to the exact energy profile for QAE-QGAN than for Meta-VQE. The quantum models / agents used in generating the Figures 14-15 graphs were used to generate ground states for interatomic distances outside range of the interatomic distances included in the training data (as well as within the range). Figure 16 illustrates these results. The three graphs show the same metrics of the three graphs in Figure 15 and duplicate description of each graph and each line is therefore omitted. The range of the training data in terms of interatomic distance is indicated by the vertical dotted lines in each graph. It will be appreciated that even outside the range of the training data, the proposed methodology (QAE- QGAN) performs better than Meta-VQE in the sense that the generated states are closer to the exact energy profde - i.e. QAE-QGAN has better accuracy than Meta-VQE.

[0170] Figure 17 illustrates the results of comparing the proposed methodology (QAE-QGAN) to another comparative method comprising using a QGAN to learn the ground states of the training data directly rather than learning the compressed latent representations. That is, in the comparative method, indicated on the graphs in Figure 17 by QGAN, a QGAN was trained such that the two inputs to the quantum discriminator were the output of the quantum generator and the ground states of the training data (i.e. rather than first training a QAE and using the quantum encoder to compress the training data so that the QGAN learns the compressed latent representations). This may be referred to as learning in the original space rather than (in the QAE-QGAN proposed methodology) learning in the quantum latent space. The QGAN in the comparative method was then used to generate ground states for a range of interatomic distances.

[0171] The three graphs in Figure 17 show the same metrics as the three graphs in Figure 15, but for the QGANB comparative method instead of (in Figure 15) the Meta-VQE comparative method and duplicate description of each graph and each line is therefore omitted. In each graph, the lines with crosses indicate the results of the QAE-QGAN methodology and the lines with dots indicate the results of the comparative QGAN methodology. On the top graph the short-dashed line indicates the exact energy profile. It will be appreciated from Figure 17 that the proposed methodology (QAE-QGAN) is more accurate than the comparative QGAN method in generating ground states, when trained on the same set of training data, in the sense that the energy profile of the generated (synthetic) states is closer to the exact energy profile for QAE-QGAN than for simple QGAN. For completeness, the results for QAE- QGAN in Figure 17 are the same as the results for QAE-QGAN in Figure 15 and Figures 13 and 14. The quantum models / agents used in generating the Figure 17 graphs were used to generate ground states for interatomic distances outside range of the interatomic distances included in the training data (as well as within the range). Figure 18 illustrates these results. The three graphs show the same metrics of the three graphs in Figure 17 and duplicate description of each graph and each line is therefore omitted. The range of the training data in terms of interatomic distance is indicated by the vertical dotted lines in each graph. It will be appreciated that even outside the range of the training data, the proposed methodology (QAE- QGAN) performs better than the comparative QGAN method in the sense that the generated states are closer to the exact energy profde - i.e. QAE-QGAN has better accuracy than simple QGAN.

[0172] The superior accuracy shown using Figures 17 and 18 indicates that in the proposed methodology (QAE-QGAN) the QAE can learn the correlations in the training data which are then learned indirectly by the QGAN, thus making the QGAN training more effective.

[0173] Two examples for generating quantum states with specific properties / constraints have been described above, and these are not limiting. The proposed methodology may be applied to generating other quantum data with different properties / constraints. Oher application examples include determining the Hamiltonian of a system, Quantum state of interest, Measurement or projection operators, and in general any useful unitary transformations.

[0174] The above-described methodology has been implemented on computer hardware, and code has been developed for the end-to-end implementation using Open Source Softwares (OSS) - (i) Qiskit for the QAE module (ii) Penny Lane and PyTorch for the QGAN module.

[0175] As disclosed herein, a quantum novel architecture is introduced for learning the quantum latent space representation of a QAE and the generation of new quantum data. A QGAN is used for this task using a controllable entropy source to learn and generate new quantum data over some metric. After training, the architecture is fully-quantum and can be deployed on completely quantum hardware.

[0176] Advantages of using the QAE-QGAN proposed methodology rather than the comparative QGAN-only methodology have been described above. Furthermore, if the training data is inherently noisy, the QAE can also be used to denoise the quantum data before the learning of the quantum latent space by the QGAN.

[0177] A difficulty experienced in QGAN training is mode collapse (when a quantum generator learns to produce one output (or a small number of outputs) rather than producing broad outputs that are able to fool the discriminator). In such cases (including the classical ML analogue) the model training may be stopped at desired performance metrics. The point at which the training is stopped (to avoid mode collapse) impacts the application accuracy. As already noted, for QGAN training the Trace Distance (between the real and the fake distribution) and its polynomial functions are natural metrics for the cost function. The square of the Trace Distance may avoid the possibility of a mode collapse in theory. The Wasserstein metric (and / or its quantum extensions) may also / altematively be used in the cost function.

[0178] Methods have been described above for training a QGAN to learn a quantum latent space. Other quantum generative models may be used to learn the quantum latent space of a QAE.

[0179] Methods described above exploit the adversarial learning aspect of the QGAN for learning the quantum latent space representation of a QAE. The proposed methodology is capable of generating novel quantum states with certain properties and also to learn the energy landscape and generate ground states of a parameterized Hamiltonian.

[0180] Figure 19 is a block diagram of an information processing apparatus 10 or a computing device 10, such as a data storage server, which embodies the present invention, and which may be used to implement some or all of the operations of a method embodying the present invention, and perform some or all of the tasks of apparatus of an embodiment. The computing device 10 may be used to implement any of the method steps described above, e.g. any of steps S10-S20 and / or any of steps S30-S58 and / or any of steps S60-S66 and / or any of steps S70-S78 and / or any of steps S170-S182, and / or to implement / control operations of any of the modules / models described above, e.g. any of the quantum encoder 62, the quantum decoder 64, the quantum generator 66 and the quantum discriminator 68.

[0181] The computing device 10 comprises a processor 993 and memory 994. Optionally, the computing device also includes a network interface 997 for communication with other such computing devices, for example with other computing devices of invention embodiments. Optionally, the computing device also includes one or more input mechanisms such as keyboard and mouse 996, and a display unit such as one or more monitors 995. These elements may facilitate user interaction. The components are connectable to one another via a bus 992.

[0182] The memory 994 may include a computer readable medium, which term may refer to a single medium or multiple media (e.g., a centralized or distributed database and / or associated caches and servers) configured to carry computer-executable instructions. Computerexecutable instructions may include, for example, instructions and data accessible by and causing a computer (e.g., one or more processors) to perform one or more functions or operations. For example, the computer-executable instructions may include those instructions for implementing a method disclosed herein, or any of the method steps described above, e.g. any of steps S10-S20 and / or any of steps S30-S58 and / or any of steps S60-S66 and / or any of steps S70-S78 and / or any of steps S170-S182, and / or to implement / control operations of any of the modules / models described above, e.g. any of the quantum encoder 62, the quantum decoder 64, the quantum generator 66 and the quantum discriminator 68. Thus, the term “computer-readable storage medium” may also include any medium that is capable of storing, encoding or carrying a set of instructions for execution by the machine and that cause the machine to perform any one or more of the method steps of the present disclosure. The term “computer-readable storage medium” may accordingly be taken to include, but not be limited to, solid-state memories, optical media and magnetic media. By way of example, and not limitation, such computer-readable media may include non-transitory computer-readable storage media, including Random Access Memory (RAM), Read-Only Memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Compact Disc Read-Only Memory (CD-ROM) or other optical disk storage, magnetic disk storage or other magnetic storage devices, flash memory devices (e.g., solid state memory devices).

[0183] The processor 993 is configured to control the computing device and execute processing operations, for example executing computer program code stored in the memory 994 to implement any of the method steps / operations described herein. The memory 994 stores data being read and written by the processor 993 and may store training data and / or loss functions and / or error amounts and / or weights / parameters and / or information indicating PQC structure and / or signals indicating the state of a qubit and / or information indicating compressed latent representation matrices and / or information indicating synthetic compressed latent representation matrices and / or thresholds and / or iteration counts and / or target quantum states and / or input data and / or other data, described above, and / or programs for executing any of the method steps / operations described above. As referred to herein, a processor may include one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. The processor may include a complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets or processors implementing a combination of instruction sets. The processor may also include one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. In one or more embodiments, a processor is configured to execute instructions for performing the operations and operations discussed herein. The processor 993 may be considered to comprise any of the modules / models described above. Any operations described as being implemented by a module / model may be implemented as a method by a computer and e.g. by the processor 993.

[0184] The display unit 995 may display a representation of data stored by the computing device, such as training data and / or target quantum states and / or GUI windows and / or interactive representations enabling a user to interact with the apparatus 10 by e.g. drag and drop or selection interaction, and / or any other data / output described above, and may also display a cursor and dialog boxes and screens enabling interaction between a user and the programs and data stored on the computing device. The input mechanisms 996 may enable a user to input data and instructions to the computing device.

[0185] The network interface (network I / F) 997 may be connected to a network, such as the Internet, and is connectable to other such computing devices via the network. The network I / F 997 may control data input / output from / to other apparatus via the network. Other peripheral devices such as microphone, speakers, printer, power supply unit, fan, case, scanner, trackerball etc may be included in the computing device.

[0186] Methods embodying the present invention may be carried out on a computing device / apparatus 10 such as that illustrated in Figure 19. Such a computing device need not have every component illustrated in Figure 19, and may be composed of a subset of those components. For example, the apparatus 10 may comprise the processor 993 and the memory 994 connected to the processor 993. Or the apparatus 10 may comprise the processor 993, the memory 994 connected to the processor 993, and the display 995. A method embodying the present invention may be carried out by a single computing device in communication with one or more data storage servers via a network. The computing device may be a data storage itself storing at least a portion of the data.

[0187] A method embodying the present invention may be carried out by a plurality of computing devices operating in cooperation with one another. One or more of the plurality of computing devices may be a data storage server storing at least a portion of the data.

[0188] The invention may be implemented in digital electronic circuitry, or in computer hardware, firmware, software, or in combinations of them. The invention may be implemented as a computer program or computer program product, i.e., a computer program tangibly embodied in a non-transitory information carrier, e.g., in a machine-readable storage device, or in a propagated signal, for execution by, or to control the operation of, one or more hardware modules.

[0189] A computer program may be in the form of a stand-alone program, a computer program portion or more than one computer program and may be written in any form of programming language, including compiled or interpreted languages, and it may be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a data processing environment. A computer program may be deployed to be executed on one module or on multiple modules at one site or distributed across multiple sites and interconnected by a communication network.

[0190] Method steps of the invention, e.g. any of steps S10-S20 and / or any of steps S30-S58 and / or any of steps S60-S66 and / or any of steps S70-S78 and / or any of steps S170-S182, and / or implementation / control of operations of any of the modules / models described above, e.g. any of the quantum encoder 62, the quantum decoder 64, the quantum generator 66 and the quantum discriminator 68, may be performed by one or more programmable processors executing a computer program to perform functions of the invention by operating on input data and generating output. Apparatus of the invention may be implemented as programmed hardware or as special purpose logic circuitry, including e.g., an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit).

[0191] Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions coupled to one or more memory devices for storing instructions and data.

[0192] The processor 993 may be or comprise at least one quantum computing device or processor for implementing any of the steps or operations described above. The processor 993 may comprise at least one quantum computing device or processor for implementing any of the quantum agents described herein (e.g. any of the quantum encoder 62, the quantum decoder 64, the quantum generator 66 and the quantum discriminator 68) and / or for implementing any of steps S16, S40-S44, S54, S56, and S66. The processor 993 may comprise at least one quantum computing device / processor for implementing any of the quantum agents described herein (e.g. any of the quantum encoder 62, the quantum decoder 64, the quantum generator 66 and the quantum discriminator 68) and at least one other processor (e.g. a “classical”, i.e. non-quantum, processor) for controlling the at least one quantum computing device / processor (which implements the quantum agent(s)) according to the above-described methods.

[0193] The processor 993 may comprise at least one “classical” processor and at least one quantum computing device / processor. The at least one “classical” processor may be configured to implement methods steps and / or operations of a method / computer program, corresponding to any of the method steps described above, e.g. any of steps S10-S20 and / or any of steps S30- S58 and / or any of steps S60-S66 and / or any of steps S70-S78 and / or any of steps S170-S182, wherein some steps / operations include “using” quantum models / agents and in those operations the “classical” processor controls the at least one quantum computing device / processor to implement the quantum agents and carry out the operations.

[0194] Rather than the processor 993 comprising at least one “classical” processor and at least one quantum computing device / processor, the processor may comprise or be the at least one “classical” processor and the computing device 10 may additionally comprise at least one quantum computing device / processor configured as described above. The at least one quantum computing device / processor may be provided separately from or inside the computing device 10 and may e.g. be connected to the computing device 10 via a bus.

[0195] Figure 20 is a schematic diagram illustrating a computing device 900 comprising a classical computer construction 901 and a quantum computer configuration 902. The classical computer construction 901 comprises a central processing unit (CPU) 930, a main storage 940, an auxiliary storage 950, and input / output device(s) 960. The quantum computer configuration 902 comprises a quantum arithmetic processor (which may be referred to as a quantum processor) 910. The quantum arithmetic processor 910 may comprise a qubit device 912 and a qubit control signal generator 914. The qubit device 912 is configured to represent the physical qubits where quantum information is stored and processed, and the qubit control signal generator 914 is configured to produce the signals required to manipulate those qubits and perform the operations in the quantum arithmetic processor 910. In particular the qubit device 910 is configured to hold and manipulate quantum states, and may be implemented using various technologies, such as for instance superconducting circuits, trapped ions, or photonic systems, and the qubit control signal generator 914 is configured to manipulate the qubits of the qubit device 912 by producing control signals, such as for instance microwave pulses or laser beams etc. The computing device 900 comprises a bus 920 connecting the components described above. The auxiliary storage 950 may comprise any of an operating system (OS) 952, a quantum circuit program 954, and a quantum computational control program 956. The input / output device(s) 960 may comprise any of a display 962, a keyboard and / or mouse 964 and an external memory (memory card) 966.

[0196] The computing device 900 may be considered to correspond to the computing device 10 of Figure 19. Or the classical computer construction 901 may be considered to correspond to the computing device 10 and description of the computing device 10 may apply to the classical computer construction 901 (that is, the CPU 930 may correspond to the processor 993, the main storage 940 and auxiliary storage 950 may correspond to the memory 994, the input / output device(s) 960 may correspond to the display 995 and input 996, and the classical computer construction 901 may comprise an interface corresponding to interface 997). In other words, the CPU 930 may be configured to implement methods steps and / or operations of a method / computer program, corresponding to any of the method steps described above, e.g. any of steps S10-S20 and / or any of steps S30-S58 and / or any of steps S60-S66 and / or any of steps S70-S78 and / or any of steps S170-S182, wherein some steps / operations include “using” quantum ML models / agents and in those operations the CPU 930 may be configured to control the quantum processor 910 and carry out the operations. The computing devices 10 and 900 may be referred as information processing apparatuses.

[0197] The above-described embodiments of the present invention may advantageously be used independently of any other of the embodiments or in any feasible combination with one or more others of the embodiments.

Claims

We Claim:

1. A computer-implemented method comprising training a quantum generative adversarial network, QGAN, comprising a quantum generator and a quantum discriminator, according to a QGAN training process comprising: generating, using a quantum encoder and based on training data, compressed latent representations of the training data; generating, using the quantum generator, synthetic compressed latent representations; generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the predictions, weights of the QGAN.

2. The computer-implemented method as claimed in claim 1, further comprising, after performing the QGAN training process: generating, using the quantum generator, a target compressed latent representation; and decoding, using a quantum decoder, the target compressed latent representation to generate at least one target quantum state.

3. The computer-implemented method as claimed in claim 2, wherein the at least one target quantum state and each quantum state in the training data share at least one property.

4. The computer-implemented method as claimed in claim 3, wherein the at least one property is that each quantum state has an entanglement entropy above an entropy threshold or that each quantum state is a ground state of a molecule.

5. The computer-implemented method as claimed in any of claims 2 to 4, wherein each quantum state in the training data corresponds to and is labelled according to a value of a property, and wherein generating the target compressed latent representation comprises generating the target compressed latent representation based on a value of the property different from the values among the training data.

6. The computer-implemented method as claimed in any of the preceding claims, wherein adjusting the weights of the QGAN comprises computing a loss based on the predictions generated by the quantum discriminator.

7. The computer-implemented method as claimed in claim 6. wherein computing the loss comprises computing a trace distance.

8. The computer-implemented method as claimed in claim 6, wherein computing the loss comprises computing a generator loss based on whether the quantum discriminator’s predictions relating to the synthetic compressed latent representations are correct and computing a discriminator loss based on whether the quantum discriminator’s predictions relating to the synthetic compressed latent representations and the compressed latent representations are correct.

9. The computer-implemented method as claimed in any of the preceding claims, further comprising, before performing the QGAN training process, training a quantum autoencoder, QAE, comprising the quantum encoder and a quantum decoder by performing a QAE training process comprising: generating, using the quantum encoder and based on an instance of training data, a compressed latent representation of the instance of training data; decoding, using the quantum decoder, the compressed latent representation to generate a reconstructed instance; computing a reconstruction loss based on the instance of training data and the reconstructed instance; and adjusting, based on the reconstruction loss, at least one weight of the QAE.

10. The computer-implemented method as claimed in any of the preceding claims, wherein generating, using the quantum generator, each synthetic compressed latent representation comprises generating the synthetic compressed latent representation based on noise or parameters sampled from a distribution.

11. The computer-implemented method as claimed in any of the preceding claims, wherein generating, using the quantum generator, each synthetic compressed latent representationcomprises generating the synthetic compressed latent representation based on labelled information.

12. The computer-implemented method as claimed in any of the preceding claims, wherein using the quantum encoder, the quantum generator, and the quantum discriminator comprises controlling a parametrized quantum circuit, PQC, implementing the quantum encoder, controlling a PQC implementing the quantum generator, and controlling a PQC implementing the quantum discriminator, respectively.

13. A computer program which, when run on a computer, causes the computer to carry out a method comprising: generating, using a quantum encoder and based on training data, compressed latent representations of the training data; generating, using the quantum generator, synthetic compressed latent representations; generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the predictions, weights of the QGAN.

14. An information processing apparatus comprising a memory and a processor connected to the memory, wherein the processor is configured to carry out a QGAN training process comprising: generating, using a quantum encoder and based on training data, compressed latent representations of the training data; generating, using the quantum generator, synthetic compressed latent representations; generating, using the quantum discriminator, predictions indicating whether each of the compressed latent representations and the synthetic compressed latent representations has been generated by the quantum encoder or by the quantum generator; and adjusting, based on the predictions, weights of the QGAN.

15. A computer-implemented method comprising: generating, using a quantum generator, a compressed latent representation; and decoding, using a quantum decoder, the compressed latent representation to generate at least one target quantum state,wherein the quantum generator has been trained as part of a QGAN training process for training a quantum generative adversarial network, QGAN, comprising the quantum generator and a quantum discriminator, to generate synthetic compressed latent representations emulating compressed latent representations generated by a quantum encoder as applied to training data, wherein the training data and the target at least one quantum state share at least one property.

16. The computer-implemented method as claimed in claim 15, wherein the at least one property shared by the training data and the at least one quantum state is that each quantum state has an entanglement entropy above an entropy threshold.

17. The computer-implemented method as claimed in claim 15 or claim 16, wherein the at least one property shared by the training data and the at least one quantum state is that each quantum state is a ground state of at least one molecule.

18. The computer-implemented method as claimed in claim 17, wherein each of the ground states in the training data corresponds to and is labelled according to an interatomic distance, and generating the target compressed latent representation comprises generating the target compressed latent representation based on an interatomic distance not present among the training data.

19. A computer program which, when run on a computer, causes the computer to carry out a method comprising: generating, using a quantum generator, a compressed latent representation; and decoding, using a quantum decoder, the compressed latent representation to generate at least one target quantum state, wherein the quantum generator has been trained as part of a QGAN training process for training a quantum generative adversarial network, QGAN, comprising the quantum generator and a quantum discriminator, to generate synthetic compressed latent representations emulating compressed latent representations generated by a quantum encoder as applied to training data, wherein the training data and the target at least one quantum state share at least one property.

20. An information processing apparatus comprising a memory and a processor connected to the memory, wherein the processor is configured to: generate, using a quantum generator, a compressed latent representation; and decode, using a quantum decoder, the compressed latent representation to generate at least one target quantum state, wherein the quantum generator has been trained as part of a QGAN training process for training a quantum generative adversarial network, QGAN, comprising the quantum generator and a quantum discriminator, to generate synthetic compressed latent representations emulating compressed latent representations generated by a quantum encoder as applied to training data, wherein the training data and the target at least one quantum state share at least one property.

Images