Provably convergent quantum generative adversarial networks

Abstract

To provide a quantum generative adversarial network with provable convergence.SOLUTION: The present invention is related to a method and an apparatus for learning a target quantum state. In one aspect, a method for training a quantum generative adversarial network (QGAN) to learn a target quantum state includes a step iteratively adjusting parameters of the QGAN until a value of a QGAN loss function converges. Each iteration comprises the steps for: performing an entangling operation on a discriminator network input of a discriminator network in the QGAN to measure a fidelity of the discriminator network input, the discriminator network input including the target quantum state and a first quantum state output from a generator network in the QGAN, the first quantum state approximating the target quantum state; and performing a minimax optimization of the QGAN loss function to update the QGAN parameters, the QGAN loss function being dependent on the measured fidelity of the discriminator network input.SELECTED DRAWING: Figure 2

Description

[Technical Field]

[0001] This specification relates to quantum computing and generative adversarial networks. [Background technology]

[0002] A classical computer has a memory made up of bits, where each bit can represent either a 0 or a 1. A quantum computer holds a sequence of quantum bits, called qubits, where each quantum bit can represent a 0, a 1, or any quantum superposition of 0 and 1. A quantum computer operates by setting the qubits to an initial state and then controlling the qubits, for example, through a sequence of quantum logic gates.

[0003] Generative adversarial networks are a form of generative machine learning that achieves state-of-the-art performance in a variety of high-dimensional, complex tasks, including photorealistic image generation, super-resolution, and molecular synthesis. data A training dataset S = {x i Given access to only S, GANs can generate realistic examples outside of S. Some probability distributions are difficult to sample classically, and therefore, for any distribution p data Learning an exact representation for (x) can benefit from access to quantum computing resources. Summary of the Invention [Means for solving the problem]

[0004] This paper describes quantum generative adversarial networks with provable convergence.

[0005] In general, one innovative aspect of the subject matter described herein can be implemented in a method for training a quantum adversarial network to learn a target quantum state, the method including: iteratively adjusting parameters of the quantum adversarial network until a value of a quantum adversarial network loss function converges, each iteration including: performing an entangling operation on a discriminator network input of a discriminator network of the quantum adversarial network to measure fidelity of the discriminator network input, the discriminator network input including the target quantum state and a first quantum state output from a generator network of the quantum adversarial network, the first quantum state approximating the target quantum state; and performing minimax optimization of the quantum adversarial network loss function to update parameters of the quantum adversarial network, the quantum adversarial network loss function depending on the measured fidelity of the discriminator network input.

[0006] Other implementations of these aspects include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods. One or more classical and / or quantum computer systems may be configured to perform particular operations or actions by having software, firmware, hardware, or a combination thereof installed on the system that causes the system to perform the actions during operation. One or more computer programs may be configured to perform particular operations or actions by including instructions that, when executed by a data processing device, cause the device to perform the actions.

[0007] These and other implementations may each optionally include one or more of the following features, alone or in combination: In some implementations, the value of the quantum generative adversarial network loss function converges to a Nash equilibrium.

[0008] In some implementations, each iteration further includes processing an initial quantum state by a generator network to output a first quantum state, the processing including applying a first quantum circuit to the initial quantum state, and wherein i) the first quantum circuit is a parameterized quantum circuit, and the first quantum circuit parameters constitute generator network parameters included in the parameters of the quantum generative adversarial network.

[0009] In some implementations, the first quantum circuit has a smaller circuit depth than the quantum circuit used to generate the target quantum state.

[0010] In some implementations, the entanglement operation includes a parameterized entanglement operation that approximates a swap test.

[0011] In some implementations, the entanglement operation includes an ancilla-free swap test.

[0012] In some implementations, the unaided swap test approximates the strict swap test and includes a second quantum circuit, the second quantum circuit being a parameterized quantum circuit, and the second quantum circuit parameters constitute discriminator network parameters included in the parameters of the quantum generative adversarial network.

[0013] In some implementations, the quantum generative adversarial network loss function comprises one minus the measured fidelity of the discriminator network input.

[0014] In some implementations, performing minimax optimization of the quantum generative adversarial network loss function includes fixing the generator network parameters to values ​​determined in the previous iteration and maximizing the quantum generative adversarial network loss function with respect to the discriminator network parameters to determine updated values ​​of the discriminator network parameters for the iteration, and fixing the discriminator network parameters to the updated values ​​of the discriminator network parameters for the iteration and minimizing the quantum generative adversarial network loss function with respect to the generator network parameters to determine updated values ​​of the generator network parameters for the iteration.

[0015] In some implementations, the method further includes fixing the discriminator network parameters to values ​​corresponding to a perfect swap test and minimizing a quantum generative adversarial network loss function with respect to the generator network parameters to determine initial updated values ​​of the generator network parameters for the iteration; fixing the generator network parameters to the initial updated values ​​and maximizing the quantum generative adversarial network loss function with respect to the discriminator network parameters to determine updated values ​​of the discriminator network parameters for the iteration; and fixing the discriminator network parameters to the updated values ​​of the discriminator network parameters for the iteration and minimizing the quantum generative adversarial network loss function with respect to the generator network parameters to determine updated values ​​of the generator network parameters for the iteration.

[0016] In some implementations, the target quantum state includes a superposition state, and the method further includes generating, by the generator network, the target quantum state to approximate the quantum random access memory according to the trained generator network parameters.

[0017] In some implementations, the method further includes training a quantum neural network using the generated target quantum state.

[0018] In some implementations, the step of iteratively adjusting the parameters of the quantum generative adversarial network until the value of the quantum generative adversarial network loss function converges generates trained generator network parameters and discriminator network parameters, and the method further includes using the generator network to generate a goal state according to the trained generator network parameters.

[0019] In some implementations, performing a minimax optimization of the quantum generative adversarial network loss function to update the parameters of the quantum generative adversarial network includes performing multiple circuit evaluations to calculate gradients of the parameters of the quantum generative adversarial network.

[0020] In general, another innovative aspect of the subject matter described herein may be implemented in a quantum generative adversarial network system implemented by one or more quantum computers, wherein the quantum generative adversarial network includes a discriminator network configured to perform an entanglement operation on a discriminator network input to measure the fidelity of the discriminator network input, the discriminator network input including a target quantum state and a first quantum state output from a generator network included in the quantum generative adversarial network system, the first quantum state approximating the target quantum state.

[0021] The subject matter described herein can be implemented in a particular manner to realize one or more of the following advantages.

[0022] The presently described entangling quantum generative adversarial network (EQ-GAN) is proven to converge to a globally optimal Nash equilibrium, converging on problem instances where conventional quantum generative adversarial networks (QGANs) fail.

[0023] Furthermore, the task of learning quantum circuits to generate unknown quantum states can also be solved in a fully supervised manner. Rather than adversarially training a discriminator to distinguish between fake and real data, the discriminator can be frozen to perform an exact swap test, measuring the fidelity of the state between real and fake data. While this replicates the original state in the absence of noise, gate errors in the discriminator implementation cause convergence to a false optimum. EQ-GAN's adversarial approach is shown to be more robust to such errors than simpler supervised learning approaches. Because training quantum machine learning models can require significant time to compute gradients on current quantum hardware, tolerance to drifting gate errors during the training process is particularly valuable in the noisy intermediate-scale quantum (NISQ) era of quantum computing.

[0024] Furthermore, we present the application of EQ-GAN in the broader context of quantum machine learning for classical data. Most quantum machine learning algorithms that promise exponential speedup over classical machine learning algorithms require quantum random access memory (QRAM). EQ-GAN can be used to create an approximate QRAM by training a shallow quantum circuit to generate a superposition of classical data. The application of such a QRAM to a quantum neural network can be shown to improve the classification accuracy of the quantum neural network over that of a classical dataset in the same amount of training time. Once trained, the quantum neural network can be easily inverted to provide interpretability for its classification process. EQ-GAN offers a new paradigm for loading classical data into a quantum state prepared by a shallow quantum circuit through variational circuit optimization.

[0025] The details of one or more implementations of the subject matter herein are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the subject matter will become apparent from the description, drawings, and claims. [Brief explanation of the drawings]

[0026] [Figure 1] 1 is a graph showing the performance of a conventional quantum generative adversarial network. [Figure 2] FIG. 1 illustrates an exemplary entangled quantum generative adversarial network. [Figure 3] 1 is a flowchart of an exemplary process for training a quantum generative adversarial network to learn a target quantum state, the quantum generative adversarial network including a generator network and a discriminator network. [Figure 4A] FIG. 1 is a circuit diagram illustrating an exemplary EQ-GAN classifier architecture. [Figure 4B] FIG. 1 illustrates an exemplary representation of a unitary operator. [Figure 5] FIG. 10 is a circuit diagram of an unassisted swap test between two three-qubit states. [Figure 6] 1 is a graph showing a comparison between a QGAN for learning quantum states and the currently described EQ-GAN. [Figure 7] The first graph plots a comparison of EQ-GAN and a supervised learner implemented on a simulated quantum device, and the second graph plots a comparison of EQ-GAN and a supervised learner implemented on a physical quantum device. [Figure 8] FIG. 1 shows the ansatz of two variational QRAMs to generate a peak. [Figure 9] FIG. 1 shows the full dataset with two peaks and the variational QRAM of the training dataset. [Figure 10] FIG. 1 illustrates an exemplary quantum neural network architecture and its corresponding layout on a physical device. [Figure 11] FIG. 1 illustrates a decomposition of a rank-4 two-qubit entangling gate. [Figure 12] FIG. 1 illustrates an exemplary system. DETAILED DESCRIPTION OF THE INVENTION

[0027] Like reference numbers and designations in the various drawings indicate like elements.

[0028] Generative adversarial networks (GANs) are based on a parameterized generator network G(θ g , z) and a parameterized classifier network D(θ d ; z). The generator generates a vector sampled from the input distribution z~p0(z) into the data example G(θ g , z), and thus transform p0(z) into a new distribution p g (z). The classifier takes an input sample x and calculates the probability D(θ) that the sample is real (from the data) or fake (from the generator network). d ; z). Training corresponds to a minimax optimization problem, alternating between improving the classifier's ability to distinguish between real and fake samples and improving the generator's ability to fool the classifier. For example, with respect to the cost function V given by the following equation (1),

[0029]

number

[0030] is solved.

[0031]

number

[0032] In equation (1), θ grepresents the generator network parameters, and θ d represents the classifier network parameters, and p data (z) represents the real data distribution and p0(z) represents the input distribution.

[0033] If G and D are sufficiently powerful, e.g., approach the space of any function, then there exists a global optimum of this minimax game, and p g (x) = p data (x). Multilayer perceptrons can be used to parameterize D and G, but it is also possible to increase the dimensionality of the function space by replacing classical neural networks with quantum neural networks. In the most common case, classical data is represented by a density matrix σ = Σ i p i |ψ i ><ψ i can be represented by |, and p i ∈[0, 1] represents the bounded real numbers, and |ψ i > is an orthogonal basis state. In the original proposal of quantum GAN (QGAN), a generator network generates a quantum state ρ = U(θ g )ρ0U † (θ g ) is defined by a quantum circuit U that outputs either true data σ or false data ρ, performs a positive operator valued measurement (POVM), and returns either a true data operator T or a false data operator F,

[0034]

number

[0035] Therefore, any state ρ in The probability that is true data is

[0036]

number

[0037] QGAN solves the min-max game given by, for example, Equation (3) below.

[0038]

number

[0039] Since the set of positive operators whose 1-norm is less than or equal to 1 is convex and compact, gradient descent can be used to optimize the classifier measure. The optimal classifier measure is given by the Helstrom measurement, and the operator P + (σ-ρ) and 1 - P + (σ-ρ) distinguishes between the positive and negative parts of σ-ρ, i.e., strictly positive eigenvalues

[0040]

number

[0041] and strictly negative eigenvalues

[0042]

number

[0043] (The corresponding eigenstate

[0044]

number

[0045] and

[0046]

number

[0047] (having

[0048]

number

[0049] Given, the optimal classifier is

[0050]

number

[0051] and F = 1 - P + (σ-ρ) D(θ d , σ) - D(θ d , ρ(θ g )) = Tr[Tσ] - Tr[Tρ(θ g )] > 0 to reach a Nash equilibrium, the generator g θ ) increases g must be modified. Some methods propose the update ρ→ρ' = ρ + α(σ-ρ) for α > 0 by minimizing equation (3), but this strategy does not yield a Nash equilibrium. The evaluation of the trace by the T operator aligns the generated data only to the positive projection of σ-ρ. This eventually leads to a mode collapse, as shown in the example below.

[0052] Consider a generator initialized with true data states σ and ρ, where each state is

[0053]

number

[0054]

number

[0055] is defined by, where σ x represents the Pauli operator x, and σ y represents the Pauli operator y. σ-ρ=σ y Maximizing equation (3) with the Hellstrom measurement by decomposing / 2 yields the discriminator:

[0056]

number

[0057] Optimizing over the space of density matrices, the generator rotates ρ so that it is parallel to T,

[0058]

number

[0059] In the next iteration, the classifier tries to perform a new Helstrom measurement to distinguish σ from ρ′, which is T′ = P + It results in (σ-ρ') = ρ. When the generator is retuned to fit the new measurement operator, ρ'' = ρ. Now, it is easy to see that if a QGAN is trained to perfectly solve the minimax optimization problem at each iteration, it will not converge. Instead, it will always oscillate between states ρ' and ρ, and neither of those states is a Nash equilibrium of the minimax game for the QGAN's performance under such mode collapse.

[0060] FIG. 1 is a graph 100 illustrating the performance of a conventional QGAN learning the states defined in Equation (5) with initialization given by Equation (6). The x-axis shows the number of training episodes. The y-axis shows the loss. Graph 100 shows that mode collapse manifests as oscillations in the generator and discriminator losses without converging to a global optimum.

[0061] More broadly, we consider oscillations between a finite set of states. σ(ρ) = P + where (σ-ρ) is the optimal Helstrom measure obtained from the positive part of the spectral decomposition of σ-ρ in Eq. (4).

[0062]

number

[0063] Let represent.

[0064]

number

[0065] If T is a k-fold composition of T with itself, then T (k) = ρ is sufficient to guarantee oscillations between k states. For an n-qubit system, this can be achieved by preparing target and initial states separated by an angle π / 3 on the generalized Bloch sphere.

[0066] This problem only exists consistently when the QGAN's discriminator is allowed to converge to the Helstrom measure during training, but it can make the QGAN architecture more sensitive to the choice of hyperparameters, particularly the learning rate and number of epochs over which the discriminator and generator are trained at each iteration. When the QGAN's discriminator and generator are fully trained, mode collapse is shared by both ρ and ρ', thus resulting in a constant ¾ fidelity throughout the oscillations. However, even in a regime of standard learning rates and only one epoch per iteration, the QGAN oscillates at the beginning of training. Unstable training is difficult to overcome even in classical GAN ​​architectures, and therefore, advances in understanding how to prevent such non-convergence are important for both quantum and classical machine learning.

[0067] This specification describes a new quantum GAN that does not experience the mode collapse described above and therefore provides a more robust QGAN architecture. The new quantum GAN is an entangled QGAN (referred to herein as EQ-GAN) that entangles both true and false data, instead of providing the classifier with either true or false data.

[0068] Example Operating Environment FIG. 2 is a block diagram of an entangled quantum generative adversarial network (EQ-GAN) 200.

[0069] EQ-GAN 200 includes true-data state generator 202. True-data state generator 202 includes quantum hardware configured to generate a target quantum state, e.g., true-data state 208. In some implementations, true-data state generator 202 can prepare the target quantum state by applying a quantum circuit to an initial quantum state. In some cases, for example, when the target quantum state is a superposition of classical data, the quantum circuit required to generate a particular target quantum state may include quantum logic gates that are expensive to implement and / or may have a large circuit depth. Thus, generating a large number of target quantum states may be inefficient or infeasible.

[0070] EQ-GAN 200 also includes a generator network 204. Generator network 204 is configured to generate a quantum state, e.g., a false data state 210, that approximates the target quantum state. For example, as described in more detail below, the generator network may include quantum computing hardware configured to apply a parameterized quantum circuit to an initial quantum state to output a quantum state that approximates the target quantum state. The parameterized quantum circuit may have a smaller circuit depth compared to the quantum circuit implemented by true data state generator 202 for generating the exact target quantum state. Thus, training generator network 204 by adjusting parameterized quantum circuit parameters until the value of the EQ-GAN loss function converges can enable generator network 204 to generate an accurate approximation of the target quantum state at a lower computational cost. Exemplary operations performed by generator network 204 are described in more detail below with reference to FIGS. 3-11. Exemplary hardware included in generator network 204 is described in more detail below with reference to FIG. 12.

[0071] The EQ-GAN 200 also includes a discriminator network 206. The discriminator network 206 is configured to receive discriminator network inputs and perform an entanglement operation 214 on the discriminator network inputs to measure the fidelity 212 of the discriminator network inputs. The discriminator network inputs include true data states 208 obtained from the true data state generator 202 and false data states 210 output from the generator network 204. That is, the discriminator network 206 is configured to entangle the true data states and the false data states. The entanglement operation is a parameterized entanglement operation that approximates a swap test. In some implementations, the entanglement operation requires an ancilla qubit. In other implementations, the entanglement operation is an unaided approximation of a swap test. In either case, the entanglement operation may be implemented by application of a parameterized quantum circuit. Exemplary operations performed by the discriminator network 206 are described in more detail below with reference to FIGS. 3-11. Exemplary hardware included in the classifier network 206 is described in more detail below with reference to FIG.

[0072] The EQ-GAN 200 may be trained to enable the generator network 204 to learn a quantum circuit that generates improved approximations of a target quantum state. During training, the generation of fake data states by the generator network 204 and the learning of fidelity measures by the discriminator network 206 are adversarially optimized until a convergence criterion is met. Once trained, the generator network 204 may be used to generate an approximation 216 of a target quantum state according to the trained generator network parameters, for example, to approximate a quantum random access memory. An exemplary process for training an EQ-GAN to learn a target quantum state is described below with reference to FIG. 3.

[0073] An example process for training an EQ-GAN 3 is a flow diagram of an exemplary process 300 for training a quantum generative adversarial network to learn a target quantum state, the quantum generative adversarial network including a generator network and a discriminator network. For convenience, process 300 is described as being performed by quantum hardware in communication with control electronics located in one or more locations. For example, system 200 of FIG. 2 , suitably programmed in accordance with this specification, may perform process 300.

[0074] The system adjusts the parameters θ of the quantum generative adversarial network until the value of the quantum generative adversarial network loss function converges. g , θ d The quantum generative adversarial network loss function is described below with reference to equation (8).

[0075] At each iteration, the generator network processes an initial quantum state ρ to output a quantum state ρ (step 302). The processing may include applying a first quantum circuit U to the initial quantum state, where the first quantum circuit is a parameterized quantum circuit and the generator network parameters θ g That is, the quantum state is ρ = U(θ g )ρ0U † (θ g ), where U(θ g ) represents the parameterized first quantum circuit, and θ g represents the generator network parameters, ρ represents the initial quantum state, and the quantum state ρ is approximate to the target quantum state, and the generator network parameters θ g Iteratively adjusting the first quantum circuit U(θ g ) to generate a better approximation to the target quantum state. The processing may be performed using quantum hardware.

[0076] At each iteration, the discriminator network performs an entanglement operation on the discriminator network input to measure the fidelity of the discriminator network input (step 304). The discriminator network input includes the target quantum state and the quantum state output from the generator network. That is, the discriminator network is not directly analogous to a classical GAN ​​discriminator. Rather than evaluating either fake or true data individually, the discriminator is always provided with access to the true data σ and the input state ρ as given by Equation (7) below: in Fidelity measurement

[0077]

number

[0078] Execute.

[0079]

number

[0080] This allows the loss function of quantum adversarial generation to converge to a Nash equilibrium. The entanglement operation may be performed using quantum hardware.

[0081] The entanglement operation performed by the discriminator network is a parameterized entanglement operation that approximates a swap test. A swap test is a quantum computational procedure used to check how different two quantum states are. A swap test requires, for example, an ancillary qubit initialized in the 0 state and is performed by repeatedly applying a Hadamard gate to the ancillary qubit, applying a CSWAP (also known as a controlled swap gate or Fredkin gate) gate to a pair of qubits from a first quantum state and a second quantum state, applying the Hadamard gate to the ancillary qubit, and measuring the ancillary qubit, for example, in a Z basis, to determine how different the quantum states are.

[0082] In some implementations, the classifier network D σ (θ d , ρ in ) can be a parameterized quantum circuit that uses ancillary qubits (as in the exact swap test), and the circuit parameters constitute the discriminator network parameters.

[0083]

number

[0084] exists, i.e.,

[0085]

number

[0086] If D σ is expressive enough to arrive at an optimal discriminator during optimization. However, a conventional swap test across two n-qubit states requires a two-qubit gate spanning 2n qubits, so implementation on quantum devices with local connectivity incurs prohibitive circuit depth overhead. Therefore, in some implementations, the discriminator network can be a parameterized circuit using ancillary qubits that approximate the swap test.

[0087] FIG. 4A is a circuit diagram 400 illustrating an exemplary discriminator network architecture. The exemplary discriminator network architecture includes three quantum states 402a-c. The first quantum state 402a is an ancillary qubit prepared in an initial state, e.g., the 0 state. The second quantum state 402b is the output ρ(θ g ), e.g., false data. The third quantum state 402c is the target quantum state σ of one or more qubits, e.g., true data.

[0088] The discriminator network applies a first Hadamard gate 404 to the ancillary qubit 402a, generating the ancillary qubit 402a and the output ρ(θ g ), and the target quantum state σ, a unitary operator 406 is applied. The unitary operator 406 is d , which approximates a swap test. The unitary operator 406 can represent a sequence of quantum logic gates, and the quantum logic gates included in the sequence can vary based on the sizes of the second and third quantum states and the specific hardware implementation. For example, if the target quantum state is a single-qubit state and the output of the generator network is a single-qubit state, the sequence of quantum logic gates could include a single-qubit rotate gate, an S gate, a T gate, a Hadamard gate, a Pauli X gate, and a CZ gate. A circuit representation of an exemplary unitary operator 406 is shown in FIG. 4B. In FIG. 4B, X1 through X7 represent free parameters to be trained.

[0089] The discriminator network further applies a second Hadamard gate 408 to the ancillary qubit 402a and measures the ancillary qubit using a measurement operation 410 to obtain a discriminator output 412 representing the difference between the second quantum state 402b and the third quantum state 402c.

[0090] To further simplify the physical implementation of the classifier network, in some implementations the classifier network D σ (θ d , ρ in ) can be a parameterized circuit that does not include ancillary qubits. Instead, the discriminator network can be a parameterized circuit that performs a destructive unaided (ancillary qubit-less) approximation to the swap test.

[0091] For example, for quantum devices with planar connectivity, the CNOT gate can be used with native CZ gates.

[0092]

number

[0093] The CZ gate has an unstable error that can be effectively modeled using a Z rotation of an unknown angle on either qubit. The currently described EQ-GAN formulation can overcome single-qubit phase errors by applying an RZ(θ) gate immediately after each CZ operation. During adversarial training, the free angle θ is optimized with gradient descent to mitigate the error of the two-qubit gate. Thanks to the convergence properties provided by the generative adversarial framework, the discriminator provably converges to the best possible state discriminator. This motivates early stopping (as shown in Figure 7) when the discriminator loss indicates that the best state discriminator has been reached.

[0094] 5 is a circuit diagram 500 of an unaided approximate swap test between a first three-qubit state 502 and a second three-qubit state 504. The left side of the circuit diagram 500 shows an exact swap test 506. In a strict swap test, a first Hadamard gate 508 is applied to an ancillary qubit 510, and three CSWAP gates 512 are applied to a pair of qubits in first and second three-qubit states 502 and 504, e.g., a first CSWAP gate is applied to a first qubit in first state 502 and a first qubit in second state 504, a second CSWAP gate is applied to a second qubit in first state 502 and a second qubit in second state 504, and a third CSWAP gate is applied to a third qubit in first state 502 and a third qubit in second state 504, with the ancillary qubit 510 acting as a control for each CSWAP gate. A second Hadamard gate 514 is applied to the ancillary qubit 510, and a measurement operation 516 is performed to obtain a measured result of the ancillary qubit.

[0095] The right side of circuit diagram 500 shows an alternative implementation of swap test 518. By rewriting control swap operation 512 as a CNOT gate 520 applied to each qubit in first state 502, with each qubit in second state 504 acting as a control for each CNOT gate, a Hadamard gate 522 applied to each qubit in second state 504, a measurement operation 524 performed on each qubit in first state 502 and second state 504, and a Toffoli gate 526 applied to an ancilla classical bit, with each Toffoli gate using each qubit in first state 502 and each qubit in second state 504 as a control, and replacing the computational basis operation with classical post-processing, the swap test can be performed without the ancilla classical bit but with an ancilla classical bit (hence the term “unaided” swap test).

[0096] Returning to FIG. 3 , the system performs a minimax optimization of the quantum generative adversarial network loss function to update the parameters of the quantum generative adversarial network (step 306). The minimax optimization may be performed using one or more classical processors. The quantum generative adversarial network loss function is calculated based on the discriminator network output (measured fidelity D of the discriminator network inputs). σ (θ d , ρ(θ g ))) and is equal to 1 minus the measured fidelity of the classifier network input, as given by equation (8) below.

[0097]

number

[0098] Performing minimax optimization of the quantum generative adversarial network loss function involves the generator network parameters θ g to the values ​​determined in the previous iteration (or to the initial values ​​if the iteration is the first iteration), and the classifier network parameters θ d The quantum generative adversarial network loss function is maximized with respect to , and the discriminator network parameters are set to the discriminator network parameters θ d and the generator network parameters θ g That is, the EQGAN architecture minimizes the quantum generative adversarial network loss function with respect to the state ρ(θ g ) and fidelity measurement D σ Learning and adversarially optimizing.

[0099] Iteratively adjusting the parameters of the quantum generative adversarial network until the value of the quantum generative adversarial network loss function converges, as described above in connection with steps 302-306, produces trained generator network and discriminator network parameters that define a trained generator network and a trained discriminator network. Once trained, the generator network can generate accurate approximations to a goal state according to the trained generator network parameters, for example, as part of a QRAM described below.

[0100] It can now be shown that there exists a unique Nash equilibrium at the desired location. By definition, 0 ≤ D σ (θ d , ρ(θ g ))≦1 is the probability of measuring the state |1> at the end of the circuit shown in FIG. 4A or FIG. 5. The discriminator realizes the identity transformation, i.e.,

[0101]

number

[0102] , then the probability of observing state |1> is 0. In the first step of classifier maximization, the classifier performs a non-trivial entanglement operation on the generator output and the true data. Furthermore, U(θ d ), the maximum value for distinguishing between two arbitrary states is uniquely achieved by the angle of the complete swap test. In some cases, the discriminator does not select the swap test, but the next step is to select D from the generator side. σ (θ d , ρ(θ g )). If the discriminator does not perform a swap test, the generator can choose any new state that is not sufficiently distinguished by the discriminator because it is not using a fidelity comparison. Ultimately, the generator cannot improve if or only if the discriminator uses a swap test, at which point the unique minimum is ρin = σ.

[0103] Circuit parameterization U(θ d ) may be selected based on various factors, including the type of device being used to implement the discriminator network, the available connectivity within the device, the types of gates that can be efficiently implemented by the device, etc. For example, for near-future quantum devices with planar connectivity, fixed gates or two-qubit entangled gates can be efficiently implemented and thus form the parameterization of the circuit.

[0104] Poorly chosen circuit parameterizations can result in nonconvex loss function landscapes that are therefore difficult to optimize by gradient descent. This is a problem shared with QGANs due to the difficulty of representing arbitrary unitaries as shallow quantum circuits. Similarly, nonconvexity in classical GANs often prevents convergence. However, the EQ-GAN architecture successfully converges on problem cases that are inaccessible to fully trained, properly parameterized QGANs. Figure 6 is a graph 600 illustrating a comparison between a QGAN learning a quantum state given by Equation (5) and the currently described EQ-GAN. The x-axis represents the number of iterations. The y-axis represents the overlap with the data state. Graph 600 shows that the QGAN oscillates infinitely between two states of equal fidelity (3 / 4), while the EQ-GAN rapidly converges to perfect fidelity.

[0105] Learning to Suppress Errors EQ-GAN can achieve improved robustness against gate errors compared to simpler supervised learning approaches for learning unknown quantum states. Rather than adversarially training the parameterized swap test used as the discriminator in EQ-GAN, a full swap test can be applied at every iteration by a frozen discriminator. This may also force the generator circuit to converge to the true data, as the swap test guarantees a unique global optimum.

[0106] However, if gate errors exist in the swap test, this unique global optimum will be offset from the true data. Because EQ-GAN does not rely on an accurate parameterization of the full swap test, it can learn appropriate Ansatz to correct the coherent errors observed in near-future quantum hardware. In particular, gate parameters such as the conditional Z phase, single-qubit Z phase, and swap angle in two-qubit entanglement gates can drift and oscillate on timescales of O(10) minutes. Such unknown systematic and time-dependent coherent errors pose significant challenges for applications in quantum machine learning, where gradient computation and updates require many measurements.

[0107] Large deviations in single-qubit and two-qubit Z rotation angles can be significantly mitigated by including additional single-qubit Z phase compensation. The effectiveness and importance of such systematic error mitigation was recently demonstrated when we successfully achieved state-of-the-art accuracy in energy estimation of fermionic molecules. In training a discriminator circuit that most closely resembles the true swap test, EQ-GAN's adversarial learning provides a useful paradigm that may be broadly applicable to improving the fidelity of other near-term quantum algorithms.

[0108] The unitary of the adversarial classifier is U(θ d ), where

[0109]

number

[0110] corresponds to a perfect swap test in the absence of noise. Given a trace-preserving perfectly positive noisy channel ε, the discriminator can be modeled using the new unitary operation

[0111]

number

[0112] The supervised method is replaced by

[0113]

number

[0114] We apply the approximate swap test given by

[0115]

number

[0116] A parameter such that

[0117]

number

[0118] In general, it performs better when there exists a noisy unitary

[0119]

number

[0120] If the parameterization of is general enough to reduce the error, the ρ(θ g ) may converge closer to σ than is possible with supervised methods.

[0121] Since the classifier must converge to a swap test at the optimal Nash equilibrium, convergence may be heuristically improved in the presence of noise by two-phase training. In the first phase, the unitary

[0122]

number

[0123] Although ,may be an incomplete swap test, the discriminator is frozen at the parameters of the perfect swap test, and the generator is trained until the loss converges. In the second phase of training, the discriminator is allowed to vary adversarially with respect to the generator, and the parameters

[0124]

number

[0125] In the context of gate errors, this second phase may result in a unitary closer to true swap testing.

[0126] In other words, performing minimax optimization of the quantum adversarial network loss function may include fixing the discriminator network parameters to values ​​corresponding to a perfect swap test, and minimizing the quantum adversarial network loss function with respect to the generator network parameters to determine initial updated values ​​of the generator network parameters for the iteration; fixing the generator network parameters to the initial updated values, and maximizing the quantum adversarial network loss function with respect to the discriminator network parameters to determine updated values ​​of the discriminator network parameters for the iteration; and fixing the discriminator network parameters to the updated values ​​of the discriminator network parameters for the iteration, and minimizing the quantum adversarial network loss function with respect to the generator network parameters to determine updated values ​​of the generator network parameters for the iteration.

[0127] For example, in a noisy quantum device,

[0128]

number

[0129] Consider the task of learning a qubit Z-rotation. Following the heuristics described above, the EQ-GAN is trained with a frozen discriminator during the first half of training and adversarially during the second half. The discriminator is defined by a swap test using a CZ gate that provides the required two-qubit operation. However, to learn to correct the gate error, the discriminator adversarially learns the angle of a single-qubit Z-rotation that is inserted immediately after the CZ gate. Thus, the EQ-GAN obtains a state overlap that is significantly better than the state overlap of a full swap test.

[0130] Table I shows the average errors after multiple runs of EQ-GAN and supervised learners on experimental devices.

[0131] [Table 1]

[0132] In Table I, a comparison of EQ-GAN and supervised learners on quantum devices with 50 qubits, CZ gates, and arbitrary single-qubit gates shows that the error of EQ-GAN (i.e., 1 - fidelity of the state to the true data) is significantly smaller than that of the supervised learner, indicating successful adversarial training of the swap test with suppressed error. The uncertainty indicates 2 standard deviations.

[0133] Figure 7 shows a first graph 700 plotting a comparison between an EQ-GAN implemented on a simulated quantum device and a supervised learner, and a second graph 750 plotting a comparison between an EQ-GAN implemented on a physical quantum device and a supervised learner. In both graphs, the x-axis represents the number of iterations, and the y-axis represents the fidelity of the state to the real data. In the simulation, normally distributed noise about single qubit rotations is applied with a systematic bias away from 0, forcing the discriminator of the supervised learner to converge to an erroneous state. It has been experimentally confirmed that EQ-GAN converges to a higher state overlap by learning to correct such errors with additional single qubit rotations. The converged EQ-GAN (dashed line) is determined by the iteration at which the discriminator loss reaches an extreme value.

[0134] Application to QRAM Many quantum machine learning applications require a quantum random access memory (QRAM) for loading superposition state data. However, loading an arbitrary state can require noisy controlled rotation, and preparing a superposition of an arbitrary set of n states takes at best an O(n) operation. Given a suitable ansatz, an EQ-GAN can be used to learn a state approximately equivalent to the superposition of data. That is, the target quantum state described above with reference to FIG. 3 can be a superposition state representing the superposition of data, and once trained, a generator network can be used to generate a superposition state that approximates the QRAM according to the trained generator network parameters. Quantum acceleration can be achieved if training an EQ-GAN is computationally less expensive than the number of calls required to a QRAM in the context of another algorithm.

[0135] To demonstrate the variational QRAM, a two-peak data set sampled from different Gaussian distributions is used. While rigorously encoding the empirical probability density function requires very deep circuits and multiple-control rotations, a shallow circuit ansatz can be chosen to generate exponential peaks. Figure 8 shows the ansatz of the two variational QRAMs for generating the peaks. Class 0 corresponds to the central peak, and class 1 corresponds to the offset peak. When trained to approximate the empirical data distribution, the variational QRAM reproduces the original data set fairly faithfully. Figure 9 shows the variational QRAM for the full two-peak data set (sampled from a normal distribution, N = 120) and the training data set (N = 60). The variational QRAM is obtained by training an EQ-GAN to generate states ρ with shallow ansatz to approximate a strict superposition of states σ. Both the training and test data sets (N = 60 each) are balanced across the two classes.

[0136] As a proof-of-principle for using such a QRAM in the context of quantum machine learning, a quantum neural network can be trained using the QRAM described above, with the hinge loss computed either by considering each data entry individually (encoded as a quantum circuit) or by considering each class individually (encoded as a superposition in a variational QRAM). Assuming the same number of circuit evaluations to compute the gradient, the superposition converges to higher accuracy at the end of training, despite using an approximate distribution, as shown in Table II below.

[0137] [Table 2]

[0138] Table II shows the test accuracy (N = 60) of quantum neural networks (QNNs) either trained on all samples in the training dataset (N = 60) for one epoch, or trained in variational QRAM for an equal number of circuit evaluations. Although the QNNs trained in variational QRAM did not have direct access to the original dataset, accuracy was evaluated on the raw dataset. Uncertainties indicate 2 standard deviations.

[0139] Experiments can show the difference in performance between training a quantum neural network (QNN) with individual examples from a classical dataset and training a QNN with a superposition of data obtained from a pre-trained EQ-GAN. Any parameterized circuit with single- and two-qubit gates can be used to construct an ansatz for the QNN. With planar connectivity for quantum devices with 50 qubits, CZ gates, and any single-qubit gates, the QNN shown in Figure 10 can be implemented with a four-qubit data state. Figure 10 shows an exemplary quantum neural network architecture (left) and its corresponding layout on a quantum device (right). A four-qubit data state is constructed with the circuit shown in Figure 7 and placed in the |data> state on the blue qubit. The readout qubit (orange) then performs the parameterized two-qubit interaction shown in Figure 11. To use native CZ two-qubit gates,

[0140]

number

[0141] We implement a rank-4 entanglement gate G given by, which can be decomposed as shown in Figure 11. Instead of using the ZZ interaction as in some previous proposals, any two-qubit entanglement interaction can be freely chosen to construct the parameterized unitary.

[0142] FIG. 11 shows the decomposition of the two-qubit entanglement gate G(θ) used in the Ansatz of the QNN given by Eq. (9).

[0143] QNNs can be trained in two ways: by sampling or by superposition. As mentioned above, superposition methodologies must not use an exact superposition of the training dataset. Instead, they can use a shallow approximation obtained by pre-training the EQ-GAN. For a fair comparison, an equal number of queries to the quantum device are allowed. Consequently, for N = 60 examples with 30 examples per class, training by sampling runs for 1 epoch at 60, which corresponds to 60 iterations performed on the quantum device. However, training by superposition evaluates the superposition of each class 30 times (since there are two classes) and also accesses the quantum device for 60 iterations. Furthermore, Bayesian optimization is used to adjust the different learning rates of the sampling and superposition methodologies. In the simulations, 10 -4 From 10 -1 The Adam learning rate is optimized over 10 random parameter trials and 40 evaluations of the Gaussian process estimator. For each parameter query, the output of the QNN is averaged over 10 trials to reduce any statistical fluctuations. The final learning rate (10 for sampling) is then calculated. -3.93 and 10 for superposition -1.83 ) is evaluated over 50 trials to obtain the final performance reported in Table II along with the calculated standard deviation.

[0144] 12 shows an exemplary system 1200 for performing the classical and quantum computations described herein. The exemplary system 1200 is an example of a system in which the systems, components, and techniques described herein may be implemented, implemented as classical and quantum computer programs on one or more classical computer and quantum computing devices at one or more locations.

[0145] Exemplary system 1200 includes an exemplary quantum computing device 1202. Quantum computing device 1202 can be used to perform quantum computational operations described herein according to some implementations. Quantum computing device 1202 is intended to represent various forms of quantum computing devices. The components shown herein, their connections and relationships, and their functionality are merely exemplary and do not limit the implementation of the invention described and / or claimed herein.

[0146] Exemplary quantum computing device 1202 includes a qubit assembly 1252 and a control and measurement system 1204. The qubit assembly includes multiple qubits, e.g., qubit 1206, that are used to perform algorithmic operations or quantum computations. While the qubits shown in FIG. 12 are arranged in a rectangular array, this is a schematic depiction and is not intended to be limiting. Qubit assembly 1252 also includes adjustable coupling elements, e.g., couplers 1208, that enable interaction between coupled qubits. In the schematic depiction of FIG. 12, each qubit is adjustably coupled to each of its four neighboring qubits by a respective coupling element. However, this is an exemplary arrangement of qubits and couplers, and other arrangements are possible, including non-rectangular arrangements, arrangements that allow coupling between non-adjacent qubits, and arrangements that include adjustable coupling between three or more qubits.

[0147] Each qubit can be a physical two-level quantum system or device with levels representing logical values ​​of 0 and 1. The specific physical implementation of the qubits and how they interact with each other depends on various factors, including the type of quantum computing device included in exemplary system 1200 or the type of quantum computation the quantum computing device is performing. For example, in an atomic quantum computer, the qubits may be implemented by atoms, molecules, or solid-state quantum systems, e.g., hyperfine atomic states. As another example, in a superconducting quantum computer, the qubits may be implemented by superconducting qubits or semiconductor qubits, e.g., superconducting transmon states. As another example, in an NMR quantum computer, the qubits may be implemented by nuclear spin states.

[0148] In some implementations, quantum computation may proceed by initializing qubits at selected initial states and applying a sequence of unitary operators to the qubits. Applying a unitary operator to a quantum state may involve applying a corresponding sequence of quantum logic gates to the qubits. Exemplary quantum logic gates include one-qubit gates, e.g., Pauli X, Pauli Y, Pauli Z (also referred to as X, Y, Z), Hadamard gates, S gates, and rotations; two-qubit gates, e.g., controlled X, controlled Y, controlled Z (also referred to as CX, CY, CZ), controlled NOT gates (also referred to as CNOT), controlled swap gates (also referred to as CSWAP), and gates involving three or more qubits, e.g., Toffoli gates. Quantum logic gates may be implemented by applying control signals 1210 generated by the control and measurement system 1204 to the qubits and couplers.

[0149] For example, in some implementations, the qubits of qubit assembly 1252 may be frequency tunable. In these examples, each qubit may have an associated operating frequency that can be tuned by application of voltage pulses via one or more drive lines coupled to the qubit. Exemplary operating frequencies include a qubit idle frequency, a qubit interaction frequency, and a qubit readout frequency. Different frequencies correspond to different operations that the qubit can perform. For example, setting the operating frequency to a corresponding idle frequency may place the qubit in a state where the qubit does not strongly interact with other qubits and may be used to perform a single-qubit gate. As another example, when qubits interact through couplers with fixed coupling, the qubits may be configured to interact with each other by setting their respective operating frequencies to frequencies that depend on some gate that detunes from their common interaction frequency. In other cases, for example, when qubits interact through tunable couplers, the qubits may be configured to interact with each other by setting parameters of their respective couplers to enable interaction between the qubits and setting the respective operating frequencies of the qubits to frequencies that depend on some gate that detunes from their common interaction frequency. Such interactions may be performed to perform multi-qubit gates.

[0150] The type of control signal 1210 used depends on the physical implementation of the qubit, for example, the control signal may include an RF or microwave pulse in an NMR or superconducting quantum computer system, or an optical pulse in an atomic quantum computer system.

[0151] A quantum computation may be completed by measuring the state of the qubit using a quantum observable, such as X or Z, using the respective control signal 1210. The measurement causes a readout signal 1212 representing the measurement result to be communicated back to measurement and control system 1204. Readout signal 1212 may comprise an RF, microwave, or optical signal, depending on the physical form of the quantum computing device and / or qubit. For convenience, control signals 1210 and readout signals 1212 shown in FIG. 12 are shown addressing only selected elements of the qubit assembly (i.e., the top and bottom rows), but in operation, control signals 1210 and readout signals 1212 can address each element in qubit assembly 1252.

[0152] Control and measurement system 1204 is an example of a classical computer system that may be used to perform the various operations and other classical subroutines or calculations on qubit assembly 1252 described above. Control and measurement system 1204 includes one or more classical processors, e.g., classical processor 1214, one or more memories, e.g., memory 1216, and one or more I / O units, e.g., I / O unit 1218, connected by one or more data buses. Control and measurement system 1204 may be programmed to send sequences of control signals 1210 to the qubit assembly, e.g., to perform a selected series of quantum gate operations, and to receive sequences of readout signals 1212 from the qubit assembly, e.g., as part of performing a measurement operation.

[0153] The processor 1214 is configured to process instructions for execution within the control and measurement system 1204. In some implementations, the processor 1214 is a single-threaded processor. In other implementations, the processor 1214 is a multi-threaded processor. The processor 1214 can process instructions stored in the memory 1216.

[0154] The memory 1216 stores information within the control and measurement system 1204. In some implementations, the memory 1216 includes a computer-readable medium, a volatile memory unit, and / or a non-volatile memory unit. In some cases, the memory 1216 may include a storage device capable of providing mass storage to the system 1204, such as a hard disk device, an optical disk device, a storage device shared over a network by multiple computing devices (e.g., a cloud storage device), and / or some other mass storage device.

[0155] Input / output devices 1218 provide input / output operations to control and measurement system 1204. Input / output devices 1218 may include D / A converters, A / D converters, and RF / microwave / optical signal generators, transmitters, and receivers to send control signals 1210 to and receive readout signals 1212 from the qubit assemblies, as appropriate for the physics of the quantum computer. In some implementations, input / output devices 1218 may also include one or more network interface devices, e.g., Ethernet cards, serial communication devices, e.g., RS-232 ports, and / or wireless interface devices, e.g., 802.11 cards. In some implementations, input / output devices 1218 may include driver devices configured to receive input data and send output data to other external devices, e.g., keyboards, printers, and display devices.

[0156] Although an exemplary control and measurement system 1204 is shown in FIG. 12, implementations of the subject matter and functional operations described herein can be implemented in other types of digital electronic circuitry, or computer software, firmware, or hardware, or a combination of one or more of them, including the structures disclosed herein and their structural equivalents.

[0157] The exemplary system 1200 includes an exemplary classical processor 1250. The classical processor 1250 can be used to perform the classical computational operations described herein, such as the classical machine learning methods described herein, according to some implementations.

[0158] Implementations and operation of the subject matter described herein can be implemented in digital electronic circuitry, analog electronic circuitry, suitable quantum circuitry, or more broadly, quantum computing systems, including the structures disclosed herein and their structural equivalents, tangibly embodied software or firmware, computer hardware, or a combination of one or more of these. The term "quantum computing system" may include, but is not limited to, a quantum computer, a quantum information processing system, a quantum cryptography system, or a quantum simulator.

[0159] Implementations of the subject matter described herein can be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a tangible, non-transitory storage medium for execution by or to control the operation of a data processing apparatus. The computer storage medium can be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, one or more qubits, or a combination of one or more thereof. Alternatively or additionally, the program instructions can be encoded on an artificially generated propagated signal capable of encoding digital and / or quantum information, e.g., a machine-generated electrical, optical, or electromagnetic signal, that is generated to encode digital and / or quantum information for transmission to a receiver device suitable for execution by the data processing apparatus.

[0160] The terms quantum information and quantum data refer to information or data carried by, held, or stored in a quantum system, with the smallest significant system being a qubit, i.e., a system that defines a unit of quantum information. The term "qubit" is understood to encompass all quantum systems that may be suitably approximated as a two-level system in the corresponding context. Such quantum systems may include, for example, multi-level systems with more than two levels. By way of example, such systems may include atoms, electrons, photons, ions, or superconducting qubits. In many implementations, a computational basis state is specified by a ground state and a first excited state, although it is understood that other setups are possible in which a computational basis state is specified by a higher-level excited state.

[0161] The term "data processing apparatus" refers to digital and / or quantum data processing hardware and encompasses all types of apparatus, devices, and machines for processing digital and / or quantum data, including, by way of example, programmable digital processors, programmable quantum processors, digital computers, quantum computers, multiple digital and quantum processors or computers, and combinations thereof. An apparatus can be or further include special-purpose logic circuitry, e.g., an FPGA (field-programmable gate array), an ASIC (application-specific integrated circuit), or a quantum simulator, i.e., a quantum data processing apparatus designed to simulate or generate information about a specific quantum system. In particular, a quantum simulator is a special-purpose quantum computer that does not have the ability to perform universal quantum computations. Optionally, in addition to hardware, an apparatus can include code that creates an execution environment for digital and / or quantum computer programs, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or one or more combinations thereof.

[0162] A digital computer program, which may also be called or referred to as a program, software, software application, module, software module, script, or code, can be written in any form of programming language, including a compiled or interpreted language, or a declarative or procedural language, and can 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 digital computing environment. A quantum computer program, which may also be called or referred to as a program, software, software application, module, software module, script, or code, can be written in any form of programming language, including a compiled or interpreted language, or a declarative or procedural language, and can be converted to a suitable quantum programming language, or can be written in a quantum programming language, for example, QCL or Quipper.

[0163] A computer program may, but need not, correspond to a file in a file system. A program can be stored as part of a file holding other programs or data, e.g., one or more scripts stored in a markup language document, a single file dedicated to the program in question, or multiple organized files, e.g., files storing one or more modules, subprograms, or portions of code. A computer program can be deployed to run on one computer or on multiple computers located in one location or distributed across multiple locations and interconnected by a digital and / or quantum data communication network. A quantum data communication network is understood to be a network that may transmit quantum data using quantum systems, e.g., qubits. Generally, digital data communication networks cannot transmit quantum data, but quantum data communication networks may transmit both quantum data and digital data.

[0164] The processes and logic flows described herein may be performed by one or more programmable computers operating with one or more processors, executing one or more programs as appropriate, to perform functions by operating on input data and generating output. The processes and logic flows may also be performed by, and an apparatus may be implemented as, a special purpose logic circuit, e.g., an FPGA or ASIC, or a quantum simulator, or a combination of a special purpose logic circuit or quantum simulator with one or more programmed digital and / or quantum computers.

[0165] When one or more computer systems are "configured to" perform a particular operation or action, it means that the system has installed thereon software, firmware, hardware, or a combination thereof that, when in operation, causes the system to perform the operation or action. When one or more computer programs are configured to perform a particular operation or action, it means that the one or more programs contain instructions that, when executed by a data processing device, cause the device to perform the operation or action. For example, a quantum computer may receive instructions from a digital computer that, when executed by a quantum computing device, cause the device to perform an operation or action.

[0166] A computer suitable for executing a computer program can be based on a general-purpose or special-purpose processor, or any other type of central processing unit. In general, the central processing unit receives instructions and data from a read-only memory, a random access memory, or a quantum system suitable for transmitting quantum data, e.g., photons, or a combination thereof.

[0167] The elements of a computer include a central processing unit for performing or executing instructions and one or more memory devices for storing instructions and digital, analog, and / or quantum data. The central processing unit and memory can be supplemented by or incorporated in special purpose logic circuitry or a quantum simulator. Generally, a computer also includes one or more mass storage devices for storing data, e.g., magnetic disks, magneto-optical disks, optical disks, or quantum systems suitable for storing quantum information, or is operatively coupled to receive data from or transfer data to the mass storage devices, or both. However, a computer need not have such devices.

[0168] Quantum circuit elements (also called quantum computing circuit elements) include circuit elements for performing quantum processing operations. That is, quantum circuit elements are configured to utilize quantum mechanical phenomena such as superposition and entanglement to perform operations on data in a non-deterministic manner. Certain quantum circuit elements, such as qubits, can simultaneously represent two or more states of information and be configured to operate on such information. Examples of superconducting quantum circuit elements include circuit elements such as quantum LC oscillators, qubits (e.g., flux qubits, phase qubits, or charge qubits), and superconducting quantum interference devices (SQUIDs) (e.g., RF-SQUIDs or DC-SQUIDs), among others.

[0169] In contrast, classical circuit elements generally process data in a deterministic manner. Classical circuit elements can be configured to collectively execute the instructions of a computer program by performing basic arithmetic, logic, and / or input / output operations on data, where the data is represented in analog or digital form. In some implementations, classical circuit elements may be used to transmit data to and / or receive data from quantum circuit elements through electrical or electromagnetic connections. Examples of classical circuit elements include circuit elements based on CMOS circuits, rapid single flux quantum (RSFQ) devices, reciprocal quantum logic (RQL) devices, and ERSFQ devices, which are energy-efficient versions of RSFQ that do not use bias resistors.

[0170] In certain cases, some or all of the quantum and / or classical circuit elements may be implemented using, for example, superconducting quantum and / or classical circuit elements. Fabrication of superconducting circuit elements may involve the deposition of one or more materials, such as superconductors, dielectrics, and / or metals. Depending on the materials selected, these materials may be deposited using deposition processes such as chemical vapor deposition, physical vapor deposition (e.g., evaporation or sputtering), or epitaxial techniques, among other deposition processes. Processes for fabricating circuit elements described herein may involve removing one or more materials from the device during fabrication. Depending on the material removed, the removal process may include, for example, wet etching techniques, dry etching techniques, or lift-off processes. Materials forming the circuit elements described herein may be patterned using known lithography techniques (e.g., photolithography or electron beam lithography).

[0171] During operation of a quantum computing system using superconducting quantum and / or classical circuit elements, such as those described herein, the superconducting circuit elements are cooled in a cryostat to a temperature that allows the superconducting material to exhibit superconducting properties. A superconductor (or superconducting) material may be understood as a material that exhibits superconducting properties below its superconducting critical temperature. Examples of superconducting materials include aluminum (superconducting critical temperature 1.2 Kelvin) and niobium (superconducting critical temperature 9.3 Kelvin). Thus, superconducting structures, such as superconducting traces and superconducting ground planes, are formed from materials that exhibit superconducting properties below their superconducting critical temperature.

[0172] In particular implementations, control signals for quantum circuit elements (e.g., qubits and qubit couplers) may be provided using classical circuit elements that are electrically and / or electromagnetically coupled to the quantum circuit elements. The control signals may be provided in digital and / or analog form.

[0173] Suitable computer-readable media for storing computer program instructions and data include, by way of example, all forms of non-volatile digital and / or quantum memories, media, and memory devices, including semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices, magnetic disks, e.g., internal hard disks or removable disks, magneto-optical disks, CD-ROM disks and DVD-ROM disks, and quantum systems, e.g., trapped atoms or electrons. A quantum memory is understood to be a device capable of storing quantum data with high fidelity and efficiency for long periods of time, e.g., a light-matter interface where light is used for transmission and matter is used to store and preserve the quantum characteristics of the quantum data, such as superposition or quantum coherence.

[0174] Control of the various systems described herein, or portions thereof, may be implemented in a computer program product stored on one or more non-transitory machine-readable storage media and including instructions executable on one or more processing devices. The systems described herein, or portions thereof, may each be implemented as an apparatus, method, or system that may include one or more processing devices and memory for storing executable instructions for performing the operations described herein.

[0175] While this specification contains many specific implementation details, these should not be considered limitations on the scope of what may be claimed, but rather as descriptions of features that may be specific to particular implementations. Certain features described herein in the context of separate implementations may also be implemented in combination in a single implementation. Conversely, various features described in the context of a single implementation may also be implemented in multiple implementations separately or in any suitable subcombination. Furthermore, while features may be described above as working in a particular combination, and may even be initially claimed as such, one or more features of a claimed combination may in some cases be deleted from the combination, and the claimed combination may be directed to a subcombination or a variation of the subcombination.

[0176] Similarly, while operations are shown in a particular order in the figures, this should not be understood as requiring that such operations be performed in the particular or sequential order shown, or that all of the operations shown be performed, to achieve desired results. In certain situations, multitasking and parallel processing may be advantageous. Furthermore, the division of various system modules and components in the above-described implementations should not be understood as requiring such division in all implementations, and it should be understood that the described program components and systems may generally be integrated together in a single software product or packaged in multiple software products.

[0177] Particular implementations of the subject matter have been described. Other implementations are within the scope of the appended claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results. As an example, the processes depicted in the accompanying figures do not necessarily require the particular order shown or sequential order to achieve desirable results. In some cases, multitasking and parallel processing may be advantageous. [Explanation of symbols]

[0178] 100 graphs 200 Entangled Quantum Generative Adversarial Networks (EQ-GAN) 202 True Data State Generator 204 Generator Network 206 Classifier Network 208 True Data State 210 False Data State 212 Fidelity 214 Entanglement 216 Target quantum state 300 processes 400 Circuit Diagram 402a-c Quantum states, auxiliary qubits 404 First Hadamard Gate 406 Unitary Operators 408 Second Hadamard Gate 410 Measurement Operation 412 Classifier output 500 Circuit Diagram 502 first three-qubit state, first state 504 Second three-qubit state, second state 506 Strict Swap Test 508 First Hadamard Gate 510 auxiliary qubits 512 CSWAP gate, controlled swap operation 514 Second Hadamard Gate 516 Measurement Operation 518 Swap Test 520 CNOT Gate 522 Hadamard Gate 524 measurement operation 526 Toffoli Gate 600 graphs 700 First Graph 750 Second Graph 1200 System 1202 Quantum Computing Devices 1204 Control and Measurement Systems 1206 Cubit 1208 Combiner 1210 Control Signal 1212 readout signal 1214 Classical Processor 1216 memory 1218 I / O Unit 1250 Classic Processor 1252 Cubit Assembly

Claims

1. A method implemented by one or more quantum computers, comprising: receiving, by a quantum random access memory implemented by said one or more quantum computers, a call for superposition of classical data; loading, by the quantum random access memory, a quantum state that approximates a superposition of the classical data, applying, by a generator network implemented by the one or more quantum computers, a quantum circuit to an initial quantum state to obtain the quantum state; wherein the parameters of the quantum circuit include trained values ​​that optimize a loss function; the loss function depends on the fidelity between the output of the generator network and a quantum state representing an exact superposition of the classical data, the fidelity being measured by entangling the output of the generator network and the quantum state representing the exact superposition of the classical data. method.

2. The method described in claim 1, wherein the call for superposition of the classical data is included in a quantum machine learning algorithm executed by the one or more quantum computers.

3. The method described in claim 1, wherein the quantum circuit has a smaller circuit depth than the quantum circuit used to generate the quantum state representing the exact superposition of the classical data.

4. The method of claim 1, wherein the loss function comprises 1 minus the fidelity between the output of the generator network and the quantum state representing an exact superposition of the classical data.

5. The method of claim 1, wherein entangling the output of the generator network with the quantum state representing an exact superposition of the classical data includes performing a parameterized entanglement operation that approximates a swap test.

6. The method of claim 1, wherein entangling the output of the generator network with the quantum state representing an exact superposition of the classical data includes performing an unassisted swap test.

7. The method of claim 6, wherein the unassisted swap test approximates a strict swap test and includes a second quantum circuit, the second quantum circuit being a parameterized quantum circuit, and the parameters of the second quantum circuit include trained values ​​that optimize the loss function.

8. The method of claim 7, further comprising: performing a minimax optimization of the loss function to determine the parameters of the quantum circuit, wherein the performing, in each iteration of a plurality of iterations, fixing the parameters of the quantum circuit to values ​​determined in a previous iteration and maximizing the loss function with respect to parameters of the second quantum circuit to determine updated values ​​of the parameters of the second quantum circuit for the iteration; fixing the parameters of the second quantum circuit to the updated values ​​and minimizing the loss function with respect to the parameters of the quantum circuit to determine updated values ​​of the parameters of the quantum circuit for the iteration. The method of claim 7.

9. The method of claim 8, further comprising: performing a minimax optimization of the loss function to determine the parameters of the quantum circuit, wherein the performing, in each iteration of a plurality of iterations, fixing parameters of the second quantum circuit to values ​​corresponding to a perfect swap test, and minimizing the loss function with respect to parameters of the quantum circuit to determine initial updated values ​​of the parameters of the quantum circuit for the iteration; fixing generator network parameters to the initial updated values ​​and maximizing the loss function with respect to parameters of the second quantum circuit to determine updated values ​​of the parameters of the second quantum circuit for the iteration; fixing the parameters of the second quantum circuit to the updated values ​​of the parameters of the second quantum circuit for the iteration, and minimizing the loss function with respect to the parameters of the quantum circuit to determine updated values ​​of the parameters of the quantum circuit for the iteration. The method of claim 7.

10. A system comprising one or more quantum computers, the system being configured to perform operations in accordance with a method according to any one of claims 1 to 9.

Images