Systems, computer-implemented methods, and computer program products for facilitating a backend quantum runtime

Abstract

The present disclosure relates to systems, computer-implemented methods, and computer program products for facilitating a backend quantum runtime. Systems and techniques are provided that facilitate a backend quantum runtime. In various embodiments, a system can include a backend receiver component that can access a computer program provided by a client device, where the computer program is configured to instruct a quantum computation. In various aspects, the system can further include a backend runtime manager component that can host the computer program by instantiating a backend classical computing resource. In different cases, the backend classical computing resource can orchestrate both a classical execution of the computer program and a quantum execution of the quantum computation instructed by the computer program.

Description

Background Technology

[0001] This disclosure relates to quantum computing, and more specifically to a backend quantum runtime that can efficiently provide quantum computing as a remote service.

[0002] Recently, the field of quantum computing has seen an increase in algorithms that utilize both classical and quantum processing. In other words, the execution of classical quantum algorithms can be facilitated by utilizing both classical and quantum computing resources. While classical computing resources are widely available, quantum computing resources are not, because quantum computing is still in its early stages, and the physical environment of existing quantum hardware must be finely controlled to maintain coherence and minimize harmful noise effects. Therefore, some industry players specializing in the construction and maintenance of quantum hardware offer quantum computing as a remote service. Clients wishing to execute classical quantum algorithms can do so by utilizing such remote quantum computing services.

[0003] Existing remote quantum computing services exhibit a separation between classical and quantum computing resources, with classical computing resources exclusively located on the client side and quantum computing resources exclusively located on the server side. The inventors of this invention recognize that this separate remote service architecture can exhibit poor performance due to the high-latency interaction between classical and quantum computing resources. Therefore, the inventors of this invention have observed that systems and / or techniques that can solve this technical problem may be desirable. Summary of the Invention

[0004] The following overview is presented to provide a basic understanding of one or more embodiments of the invention. This overview is not intended to identify key or essential elements, or to depict any scope of a particular embodiment or any scope of the claims. Its sole purpose is to present concepts in a simplified form as a prelude to the more detailed description that follows. In one or more embodiments described herein, devices, systems, computer-implemented methods, apparatuses, and / or computer program products that can facilitate backend quantum runtime are described.

[0005] According to one or more embodiments, a system is provided. The system may include a memory that can store computer-executable components. The system may further include a processor operatively coupled to the memory and capable of executing the computer-executable components stored in the memory. In various embodiments, the computer-executable component may include a receiver component capable of accessing a computer program provided by a client device. In various cases, the computer program may be configured to instruct quantum computing. In various aspects, the computer-executable component may also include a backend runtime manager component that can host the computer program by instantiating a backend classical computing resource. In various cases, the backend classical computing resource may orchestrate both classical execution of the computer program and quantum execution of the quantum computing instructed by the computer program. In various cases, the system may further include at least one backend quantum computing device capable of performing the quantum computing instructed by the computer program in response to instructions from the backend classical computing resource.

[0006] According to one or more embodiments, the above system can be implemented as a computer-implemented method and / or computer program product. Attached Figure Description

[0007] Figure 1 A block diagram of an example, non-limiting system for facilitating backend quantum runtime according to one or more embodiments described herein is shown.

[0008] Figure 2 A block diagram of an example, non-limiting system including a computer program that facilitates backend quantum runtime according to one or more embodiments described herein is shown.

[0009] Figure 3 A block diagram of an example, non-limiting computer program including quantum computing within a classical optimization loop, according to one or more embodiments described herein, is shown.

[0010] Figure 4 A block diagram of an example, non-limiting system including a runtime container that facilitates a backend quantum runtime, according to one or more embodiments described herein, is shown.

[0011] Figure 5 A block diagram of an example, non-limiting system comprising quantum results and / or program results that facilitate backend quantum runtime, according to one or more embodiments described herein, is shown.

[0012] Figure 6 A flowchart illustrating an example, non-limiting computer implementation of a method for facilitating backend quantum runtime according to one or more embodiments described herein is shown.

[0013] Figure 7 A communication diagram illustrating an example, non-limiting workflow for facilitating backend quantum runtime according to one or more embodiments described herein.

[0014] Figure 8 A flowchart illustrating an example, non-limiting computer implementation of a method for facilitating backend quantum runtime according to one or more embodiments described herein is shown.

[0015] Figure 9 A block diagram illustrating an example, non-limiting operating environment that may facilitate one or more embodiments described herein.

[0016] Figure 10 Examples of non-limiting cloud computing environments based on one or more embodiments described herein are shown.

[0017] Figure 11 An example, non-limiting abstract model layer, is shown according to one or more embodiments described herein. Detailed Implementation

[0018] The following detailed description is illustrative only and is not intended to limit the embodiments and / or their application or use. Furthermore, it is not intended to be construed as being limited by any express or implied information presented in the preceding Background or Summary of the Invention section or the Detailed Description section.

[0019] One or more embodiments will now be described with reference to the accompanying drawings, wherein like reference numerals are used throughout to refer to like elements. In the following description, numerous specific details are set forth for purposes of explanation in order to provide a more thorough understanding of the one or more embodiments. However, it will be apparent that, in various cases, the one or more embodiments described may be practiced without these specific details.

[0020] Recently, the field of quantum computing has seen an increase in algorithms that utilize both classical and quantum processing. That is, the execution of such classical quantum algorithms can be facilitated by utilizing both classical computing resources (e.g., classical computers that use bits to represent and process information) and quantum computing resources (e.g., quantum computers and / or quantum hardware that use qubits to represent and process information). For example, in some cases, classical quantum algorithms may require quantum computation within a classical optimization loop (e.g., each iteration of a classical optimization loop may require the execution of quantum computation). Non-limiting examples of such classical quantum algorithms include variational quantum eigenvalue solvers (VQEs) and quantum approximation optimization algorithms (QAOAs). Since classical computing resources cannot perform quantum computation, such classical quantum algorithms cannot be facilitated solely by classical computing resources. Instead, such classical quantum algorithms can be facilitated by classical computing resources that interact with quantum computing resources.

[0021] Classical computing resources are widely available (e.g., desktop computers, laptops, and / or smartphones are non-limiting examples of classical computing resources). In contrast, quantum computing resources are not yet widely available. This is partly because quantum computing is still in its early stages. In fact, existing quantum hardware (e.g., noisy mid-sized quantum hardware) is limited in the number of qubits that can be implemented and typically requires extensive error correction to provide reliable results. This is also partly due to the need for fine-grained control over the physical environment of existing quantum hardware. In fact, existing quantum hardware must be kept at low temperatures to maintain coherence and minimize harmful noise effects. Because quantum computing resources can be very difficult to create and operate, some industry companies focus on building and maintaining them. Furthermore, such companies can offer quantum computing resources to customers as a remote service (e.g., cloud service). Clients wishing to perform classical quantum algorithms can then utilize such remote quantum computing services to do so.

[0022] Existing remote quantum computing services can operate as follows: First, a client device (e.g., a desktop computer, laptop computer) can perform classical processing (e.g., performing the current iteration of a classical optimization loop of a classical quantum algorithm). In various aspects, this classical processing can specify and / or otherwise indicate the quantum computation to be performed (e.g., identifying one or more specific quantum circuits to be applied to one or more specific quantum states). In various cases, the client device can send instructions to the remote quantum computing service to perform quantum computation. In various aspects, the instructions can be transmitted over the Internet, received through the application programming interface of the remote quantum computing service, and placed in a queue of the remote quantum computing service. In various instances, the remote quantum computing service can retrieve the instructions from the queue and execute the quantum computation specified in the instructions on quantum hardware (e.g., a quantum substrate comprising qubits operable by microwave pulses). In various cases, the remote quantum computing service can transmit the results generated by the quantum hardware back to the client device. In various aspects, the client device can complete its classical processing (e.g., performing the current iteration of a classical optimization loop) by utilizing the results provided by the remote quantum computing service.

[0023] As explained above, existing remote quantum computing services can exhibit a separation between classical and quantum computing resources. More specifically, classical computing resources can be exclusively located on the client side, and quantum computing resources can be exclusively located on the service side. The inventors of this invention recognize that this separate architecture can exhibit poor performance due to the high-latency interaction between classical and quantum computing resources. In fact, as described above, quantum computing instructions sent from the client device are only executed by the remote quantum computing service after they have traversed the internet, passed through an application programming interface (API), and waited in a queue. Therefore, the transmission of quantum computing instructions from the client device to the remote quantum computing service can be considered a high-latency interaction (e.g., time is spent for the quantum computing instructions to reach the API via the internet, be accepted by the API, and / or wait in the queue). If the client device is executing a classical quantum algorithm involving classical optimization loops, then the client device can have many repetitive high-latency interactions with the remote quantum computing service (e.g., for each iteration of the classical optimization loop, the client device can transmit one or more quantum computing instructions to the remote quantum computing service). Thus, high-latency interactions can accumulate rapidly, which can undesirably increase the amount of time required for the client device to complete the classical quantum algorithm. Systems and / or technologies that can solve this technical problem may be desirable.

[0024] Various embodiments of the present invention can solve one or more of these technical problems. Specifically, various embodiments of the present invention can provide systems and / or technologies that can facilitate backend quantum runtime. In various aspects, embodiments of the present invention can be considered as a computerized tool (e.g., a combination of computer hardware and / or computer software) that can more efficiently provide remote quantum computing services to client devices compared to existing technologies.

[0025] In various scenarios, the computing tool can be considered a backend server tied to quantum hardware (e.g., co-located with and / or communicating specifically with quantum hardware). In various scenarios, the computing tool can electronically receive a computer program as input from a client device. In various aspects, the computer program can be configured to specify, identify, and / or otherwise indicate the quantum computation to be performed. In various scenarios, the computing tool can electronically host the computer program. That is, the computing tool can classically execute the computer program, thereby enabling the computer program to instruct quantum computation. Furthermore, in various scenarios, the computing tool can electronically instruct the quantum hardware it is tied to to perform quantum computation. In various aspects, the computing tool can continue and / or complete the classical execution of the computer program by utilizing the quantum results generated by the quantum hardware.

[0026] In various embodiments, such computerized tools may include receiver components, runtime manager components, quantum computing devices, recording components, and / or transmitter components.

[0027] In various embodiments, a client device may be present, which can be any suitable combination of computer-executable hardware and / or computer-executable software. For example, the client device may be a desktop computer, laptop computer, smartphone device, and / or tablet device. In various cases, the client device may electronically store, retain, and / or otherwise access the computer program. In various aspects, the computer program may be configured to specify quantum computation after and / or during classical execution. That is, the computer program may be an executable script that facilitates the execution of classical quantum algorithms (e.g., VQE and / or QAOA). For example, the computer program may include a classical optimization loop, wherein each iteration of the classical optimization loop calls and / or otherwise requests the execution of the specified quantum computation.

[0028] In various situations, the operator of a client device may expect to fully execute a computer program. However, because the computer program may involve quantum computing, the client device may not be able to fully execute it. To address this issue, the client device may communicate with the computerized tool described herein. As will be apparent from the disclosure herein, the client device and the computerized tool can be viewed as being in a client-server relationship in various situations, where the client device can be considered a front-end client and the computerized tool can be considered a back-end server performing some functions for the front-end client. In various respects, this functionality can be the full hosting and / or execution of the computer program (e.g., both classical and quantum execution), as described herein.

[0029] In various embodiments, the receiver component of the computerized tool may electronically receive and / or retrieve a computer program from a client device via any suitable wired and / or wireless electronic connection. Thus, other components of the computerized tool may interact electronically with the computer program. In various cases, the receiver component may also electronically receive and / or retrieve from the client device indications of any suitable software libraries required for executing the computer program and / or additionally relied upon by the computer program. In various aspects, the receiver component may additionally electronically receive and / or retrieve any suitable input parameters to be fed to the computer program from the client device.

[0030] In various embodiments, the runtime manager component of the computerized tool may electronically spool a runtime container of a computer program. In various aspects, a runtime container may be any suitable computer-executable software container capable of classically executing any non-quantum portion of a computer program. As some non-limiting examples, a runtime container may be a Docker® container, a Kubernetes® container, a containerd container, and / or any other suitable operating system-level virtualization capable of hosting a software application. In various cases, a computer program may be considered a software image hosted, implemented, and / or executed by a runtime container. In various cases, if a client device provides an indication to a receiver component of one or more software libraries that the computer program depends on, the runtime manager component may electronically instantiate the runtime container with such software libraries (e.g., the runtime manager component may spool the runtime container and enable the runtime container to download such software libraries from any suitable and electronically accessible data structure).

[0031] In various aspects, the runtime container can classically execute a computer program (e.g., it can execute non-quantum instructions contained within the computer program). In different cases, if a client device provides input parameters for a computer program to a receiver component, the runtime container can feed such input parameters to the computer program before and / or during such classical execution. In various aspects, such classical execution of the computer program can enable the computer program to request quantum computation based on these input parameters. For example, during the classical execution of the runtime container, the computer program can receive a specific quantum operator, a parameterized quantum circuit, and / or a set of circuit parameter values ​​as input parameters, and the goal of the computer program can be to estimate the expected value of the quantum operator. In different cases, the computer program can construct a specific quantum state (e.g., it can be represented by quantum probability amplitudes) and / or a specific quantum circuit (e.g., it can be a sequence of quantum gates) based on such input parameters. Furthermore, during the classical execution of the runtime container, the computer program can instruct that the specific quantum circuit be applied to a specific quantum state. In different cases, the instruction of the computer program to apply the specific quantum circuit to the specific quantum state can be considered and / or otherwise interpreted as an instruction and / or request for a specific quantum computation. In different situations, once this particular quantum computation is enabled, a computer program can use that particular quantum computation to estimate the expected value of the quantum operator.

[0032] In various embodiments, the quantum computing device of the computerized tool can electronically receive instructions from a runtime container to perform quantum computations directed by a computer program. In various aspects, the quantum computing device can be any suitable quantum processing unit comprising any suitable number and type of qubits coupled in any suitable arrangement. For example, the quantum computing device may include a quantum substrate (e.g., a silicon wafer), an array of superconducting qubits (e.g., transmon qubits) fabricated on the quantum substrate, and / or a microwave resonator fabricated on the quantum substrate and configured to controllably change the state of the superconducting qubits. In various instances, the quantum computing device may further include any suitable quantum error correction hardware. In various instances, the quantum computing device can perform the directed quantum computation and can return the quantum result to the runtime container. For example, suppose classical execution of the runtime container causes the computer program to request the application of a specific quantum circuit to a specific quantum state. In this case, the quantum computing device can initialize its qubits to be in the specific quantum state, and the quantum computing device can manipulate the state of its initialized qubits according to the specific quantum circuit. In various cases, the resulting quantum state of the qubits of the quantum computing device can be considered a quantum result. In various other cases, a particular quantum circuit may include measurements that produce classical bits. In various respects, such classical bits can be considered as quantum results.

[0033] In various instances, a runtime container can retrieve quantum results from a quantum computing device, and this runtime container can use the quantum results to classically generate and / or compute some program results. In other words, the runtime container can use the quantum results to continue and / or complete the classical execution of a computer program.

[0034] Suppose a computer program involves a classical optimization loop. In this case, the classical execution of the runtime container allows the computer program to iterate any suitable number of times (e.g., until a convergence criterion is met). For each iteration, the computer program can instruct a quantum computation to be performed during that iteration, and the quantum result of this quantum computation can be used to compute a program result during that iteration. Furthermore, the quantum computation for any given iteration can be based on the program results of previous iterations (and / or any persistent state carried in the computer program). Therefore, for each iteration of the computer program, the runtime container can instruct a quantum computing device to perform the quantum computation corresponding to that iteration, the runtime container can receive the quantum result corresponding to that iteration from the quantum computing device, and / or the runtime container can use that quantum result to compute a program result corresponding to that iteration. The runtime container can then move on to the next iteration.

[0035] In various embodiments, the runtime container can be bundled with a quantum computing device, thereby enabling low-latency communication between the runtime container and the quantum computing device. For example, the runtime container can be computer software running on a specific computing machine, and this specific computing machine can be physically coupled and / or physically co-located with the quantum computing device (e.g., the quantum computing device and the specific computer can be in the same room and therefore easily physically wired together), resulting in low-latency communication between the runtime container and the quantum computing device. As another example, the runtime container can be computer software running on a specific computing machine, and this specific computing machine can have a dedicated wireless electronic connection to the quantum computing device (e.g., the quantum computing device and the specific computing machine can be coupled via a fixed-bandwidth network connection not shared with other computing devices, although the quantum computing device and the specific computing machine may not be co-located), resulting in low-latency communication between the runtime container and the quantum computing device.

[0036] In various embodiments, the recording component of the computerized tool can electronically record and / or store quantum results and / or program results generated by the quantum computing device and / or runtime container. If the computer program includes classical optimization loops, the recording component can electronically record the quantum results and / or program results for each iteration. In other words, the recording component can be considered as recording intermediate results generated by the computer program (e.g., program results and / or quantum results from non-final iterations of the computer program) and final results generated by the computer program (e.g., program results and / or quantum results from the final iteration of the computer program). In various aspects, the recording component can include any suitable database and / or data structure, and / or can store / retain the intermediate and / or final results of the computer program in any suitable data format.

[0037] In various embodiments, the transmitter component of the computerized tool can electronically transmit intermediate and / or final results of a computer program to a client device.

[0038] To help clarify some of the points discussed above, consider the following non-restrictive example. Suppose that the computer program is configured to iteratively compute the expectation value of the Hamiltonian operator. Furthermore, suppose that the computer program consists of a classical optimization loop involving n iterations for any suitable positive integer n. Furthermore, suppose that each iteration involves establishing a quantum state and applying the Hamiltonian operator to that quantum state. Note that applying the Hamiltonian operator to a quantum state is quantum computation.

[0039] In this scenario, the client device can transmit a computer program, instructions for any software libraries that the computer program depends on, and an ansatz parameter to be fed to the computer program to the receiver component. In various respects, the ansatz parameter can be considered an initial guess at the expected value of the Hamiltonian operator. In different instances, the runtime manager component can instantiate a runtime container that implements / downloads the indicated software libraries and hosts the computer program. In different cases, the runtime container can feed the ansatz parameter to the computer program and can initiate classical execution of the computer program.

[0040] During the first iteration, the computer program can compute the first quantum state using the proposed parameters, and the computer program can instruct the Hamiltonian operator to be applied to the first quantum state. Thus, the runtime container can instruct the quantum computing device to initialize its qubits to the first quantum state and apply the transformation to the initialized qubits according to the Hamiltonian operator. The runtime container can receive the resulting quantum state from the quantum computing device, and the computer program can check the convergence criterion based on the resulting quantum state. If the convergence criterion has not yet been met, the computer program can update the proposed parameters and proceed to the second iteration. Here, the resulting quantum state produced by the quantum computing hardware can be considered the quantum result, while the updated proposed parameters can be considered the program result.

[0041] During the second iteration, the computer program can compute the second quantum state using the previously updated hypothetical parameters, and the computer program can instruct the Hamiltonian operator to be applied to the second quantum state. Thus, the runtime container can instruct the quantum computing device to initialize its qubits to the second quantum state and apply a transformation to the initialized qubits according to the Hamiltonian operator. The runtime container can receive the resulting quantum state from the quantum computing device, and the computer program can check the convergence criterion based on this resulting quantum state. If the convergence criterion has not yet been met, the computer program can perturb the hypothetical parameters again and can proceed to the third iteration.

[0042] The runtime container and quantum computing hardware can continue this operation for the remainder of n iterations. In this non-limiting example, this could mean that the hypothetical parameters are updated n times differently by the computer program, with the nth update representing the optimized program result produced by the computer program. In different cases, the recorder component can record the updated hypothetical parameters produced during each iteration of the computer program. Once the computer program converges (e.g., after n iterations), the transmitter component can transmit the optimized program result to the client device.

[0043] Note that in each of the n iterations, the runtime container and the quantum computing device can communicate with each other twice (e.g., the runtime container can instruct the quantum computing device to perform quantum computation, and the quantum computing device can provide the quantum result), for a total of 2n communications. However, since the runtime container and the quantum computing device can be tightly coupled (e.g., they can be juxtaposed with each other and / or in a dedicated network connection), these 2n transmissions can all be low-latency (e.g., not excessively time-consuming). In addition to these 2n low-latency transmissions, the computing tool can communicate with the client device twice (e.g., once to receive the computer program and once to provide the final program result), for a total of 2n+2 transmissions.

[0044] Now, consider how an existing remote quantum computing service would perform in this non-restricted example. The client device would host the computer program itself. That is, the client device would feed the proposed parameters to the computer program and would begin classical execution of the computer program.

[0045] During the first iteration, the computer program computes the first quantum state using the proposed parameters and instructs the Hamiltonian operator to be applied to it. The client device then sends instructions to the existing remote quantum computing service to initialize its qubits to the first quantum state and apply the transformation to the initialized qubits according to the Hamiltonian operator. The client device then receives the resulting quantum state from the existing remote quantum computing service, and the computer program checks the convergence criterion based on this result. If the convergence criterion is not yet met, the computer program updates the proposed parameters and proceeds to the second iteration. The client device and the existing remote quantum computing service continue this process for the remainder of n iterations.

[0046] Note that in each of the n iterations, the client device and the existing remote quantum computing service can communicate with each other twice (e.g., the client device can instruct the existing remote quantum computing service to perform quantum computation, and the existing remote quantum computing service can provide quantum results), totaling 2n transmissions. However, since the client device and the existing remote quantum computing service may not be tightly coupled (e.g., they may not be co-located, may not be in a dedicated network connection, or may be separated by queues), these 2n transmissions may all be high-latency (e.g., excessively time-consuming). In fact, in various cases, each of these 2n high-latency transmissions may be significantly more time-consuming than each of the 2n low-latency transmissions associated with the computing tool described herein. Thus, even though the implementation of the existing remote quantum computing service in this non-limiting example may require two fewer transmissions than the implementation of the computing tool described herein, the total amount of time consumed by the implementation of the existing remote quantum computing service (e.g., total latency) will be significantly higher than the total amount of time consumed by the implementation of the computing tool described herein (e.g., total latency).

[0047] In other words, the computerized tool described herein can exhibit significantly reduced latency compared to existing remote quantum computing services. This reduction in latency is likely due to the fact that the computerized tool can receive and host the entire computer program from the client device, which specifies the quantum computation during classical execution. That is, the computerized tool can manage both the classical execution of the computer program and the operation / execution of the quantum computation specified by that computer program in a backend environment. In effect, because the computerized tool can be tightly bound to the quantum computing device, it can efficiently perform such quantum computations without requiring expensive, high-latency transmissions to the client device during each iteration of the computer program. Conversely, while existing remote quantum computing services are themselves tightly bound to quantum computing devices, they can neither receive nor host computer programs. Instead, when implementing the prior art, the client device hosts the computer program itself, and the client device must make expensive, high-latency transmissions with the existing remote quantum computing service during each iteration of the computer program.

[0048] In other words, when providing quantum computing devices as a remote service (e.g., cloud service) in a backend environment, and when a frontend client wants to utilize the quantum computing device to execute a classical quantum computer program, the inventors of this invention recognize that latency can be significantly reduced by hosting the classical quantum computer program in the backend environment compared to prior art involving hosting the classical quantum computer program in the frontend environment. By hosting the classical quantum computer program in the frontend environment, high-latency interactions between frontend classical computing resources and backend quantum computing resources can accumulate rapidly. Conversely, by hosting the classical quantum computer program in the backend environment, both classical and quantum computing resources can be tightly bound together in the backend environment, meaning that low-latency interactions are likely to exist primarily between the classical and quantum computing resources. That is, significant latency reduction can occur when the classical quantum computer program is hosted in the backend environment.

[0049] Various embodiments of the present invention can be employed to solve problems that are inherently highly technical (e.g., facilitating backend quantum runtime), non-abstract, and cannot be performed as a set of mental actions by a human using hardware and / or software. Furthermore, some of the processes performed can be executed by a dedicated computer (e.g., a runtime manager, a quantum computing device). In various aspects, some defined tasks associated with the various embodiments of the present invention may include: access by a backend device operatively coupled to a processor to a computer program provided by a client device, wherein the computer program is configured to instruct quantum computing; and the backend device hosting the computer program via a spooled runtime container, wherein the runtime container orchestrates both the classical execution of the computer program and the quantum execution of the quantum computing instructed by the computer program. Such defined tasks are typically not performed manually by a human. Furthermore, neither the human mind nor a person with pen and paper can electronically access a computer program configured to instruct quantum computing and electronically host the computer program via a runtime container that manages both the classical and quantum executions of the computer program offline / instantiated. Conversely, the various embodiments of the present invention inherently and inextricably rely on computer technology and cannot be implemented outside of a computing environment (for example, a computer program is an inherently computerized object that cannot exist outside of a computing system; similarly, the computerized tools that handle both classical and quantum execution of computer programs in a back-end environment are also inherently computerized devices that cannot be practically implemented in any sensible way without a computer).

[0050] In various contexts, embodiments of the present invention can integrate the disclosed teachings regarding backend quantum runtime into practical applications. Indeed, as described herein, different embodiments of the invention (which may take the form of systems and / or computer-implemented methods) can be considered as a computerized tool that can reduce latency associated with remote quantum computing services. Specifically, as explained above, the computerized tool can receive a computer program from a client device, wherein the computer program is configured to request the execution of quantum computation. In various aspects, the computerized tool can spool a backend runtime container that can host the computer program in a backend environment. That is, the backend runtime container can manage both the classical execution of the computer program and the running / execution of the quantum computation requested by the computer program. In practice, the backend runtime container can be tightly coupled to a backend quantum computing device, and thus the backend runtime container can instruct the backend quantum computing device to perform the quantum computation specified by the computer program. Although this may involve multiple transfers between the backend runtime container and the backend quantum computing device, due to the tight coupling, all such transfers can be low-latency, meaning the total time consumed by such multiple transfers can be minimized. In stark contrast, when implementing existing technologies, these multiple transmissions do not occur between tightly coupled components, but rather between the client device and the existing remote quantum computing service. Because the client device and the existing remote quantum computing service are not tightly coupled, such multiple transmissions are likely to be highly latency-prone, meaning the total time consumed by such multiple transmissions may be undesirably high. In other words, the computing tools described herein can significantly reduce the communication latency of remote quantum computing services. Systems and / or technologies that can reduce the communication latency of remote quantum computing services in this way clearly constitute a concrete and tangible technological improvement in the field of quantum computing.

[0051] Furthermore, various embodiments of the present invention can control tangible, hardware-based, and / or software-based devices based on the disclosed teachings. For example, embodiments of the present invention can actually implement quantum circuits on tangible quantum hardware.

[0052] It should be understood that the accompanying drawings and the disclosure herein describe non-limiting examples of various embodiments of the invention.

[0053] Figure 1 A block diagram of an example, non-limiting system 100 that can facilitate backend quantum runtime according to one or more embodiments described herein is shown. As shown, the backend quantum runtime system 102 can be electronically integrated with a client device 104 via any suitable wired and / or wireless electronic connection.

[0054] In various aspects, client device 104 can be any suitable combination of computer-executable hardware and / or computer-executable software. For example, client device 104 can be a laptop computer, desktop computer, vehicle-integrated computer, smart mobile device, tablet device, and / or any other suitable classical computing device. In different cases, client device 104 may lack quantum hardware. For example, client device 104 may lack a quantum substrate (e.g., a silicon wafer) on which qubits (e.g., superconducting qubits) are fabricated, as well as a microwave resonator that can control the operating state of these qubits. Therefore, client device 104 cannot perform quantum computing.

[0055] In various circumstances, client device 104 may electronically store, electronically retain, and / or otherwise electronically access a computer program. In various circumstances, the computer program may be any suitable executable script, including both classical computing instructions (e.g., coded instructions that can be processed by a classical computer) and quantum computing instructions (e.g., coded instructions that can be processed by a quantum computer). For example, the computer program may identify, specify, instruct, and / or otherwise request to facilitate one or more quantum computations after and / or during classical execution. Because client device 104 may lack quantum hardware, client device 104 cannot perform such quantum computations, and therefore client device 104 alone may not be able to fully execute the computer program.

[0056] In various aspects, to address this issue, client device 104 can electronically communicate with backend quantum runtime system 102 to fully execute a computer program. In different contexts, client device 104 can be considered a front-end client, and backend quantum runtime system 102 can be considered a backend server (e.g., a cloud server) that helps client device 104 fully execute the computer program. In other words, backend quantum runtime system 102 can be considered as providing remote quantum computing services to client device 104. However, as explained herein, backend quantum runtime system 102 can exhibit significantly reduced latency compared to existing remote quantum computing services.

[0057] In various embodiments, the back-end quantum runtime system 102 may include a processor 106 (e.g., a computer processing unit, a microprocessor) and a computer-readable storage 108 operatively connected to the processor 106. The storage 108 may store computer-executable instructions that, when executed by the processor 106, cause the processor 106 and / or other components of the back-end quantum runtime system 102 (e.g., receiver component 110, runtime manager component 112, quantum computing device 114, recording component 116, transmitter component 118) to perform one or more actions. In various embodiments, the storage 108 may store computer-executable components (e.g., receiver component 110, runtime manager component 112, quantum computing device 114, recording component 116, transmitter component 118), and the processor 106 may execute these computer-executable components.

[0058] In various embodiments, the back-end quantum runtime system 102 may include a receiver component 110. In various aspects, the receiver component 110 may electronically retrieve and / or otherwise electronically access a computer program from the client device 104. That is, the client device 104 may electronically transmit the computer program to the receiver component 110. Therefore, in various cases, other components of the back-end quantum runtime system 102 may manipulate the computer program and / or otherwise interact with it. In various cases, the receiver component 110 may further electronically retrieve and / or otherwise electronically access instructions from the client device 104 regarding one or more software libraries (e.g., quantum circuit libraries) required by and / or relied upon by the computer program.

[0059] In various embodiments, the backend quantum runtime system 102 may include a runtime manager component 112. In various aspects, the runtime manager component 112 may electronically spool, electronically instantiate, and / or otherwise electronically generate runtime containers based on a computer program. In various cases, the runtime container may host the computer program. Because the backend quantum runtime system 102 may be located remotely from the client device 104 (e.g., in a backend environment such as a cloud environment, while the client device 104 may be in a frontend environment), the runtime container spooled by the runtime manager component 112 can be considered to host the computer program remotely and / or remotely from the client device 104. In various aspects, the runtime container may be any suitable software container from any suitable containerized computing paradigm. For example, the runtime container may be a Docker® container, a Kubernetes® container, and / or a containerd container. In various instances, if the client device 104 transmits instructions to the receiver component 110 regarding one or more software libraries that the computer program depends on, the runtime manager component 112 may instantiate the runtime container using such software libraries. For example, runtime manager component 112 can spool the runtime container and instruct the runtime container to download and / or otherwise install such software libraries from any suitable data structure (not shown) accessible to the runtime container. Thus, the runtime container can host computer programs.

[0060] In various embodiments, the back-end quantum runtime system 102 may include a quantum computing device 114. In various aspects, the quantum computing device 114 may include any suitable quantum hardware. For example, the quantum computing device 114 may include any suitable quantum substrate (e.g., a silicon wafer) on which any suitable number of any suitable type of qubit devices (e.g., superconducting qubits) are fabricated. In various cases, the qubits may be arranged on such a quantum substrate and / or coupled together in any suitable manner (e.g., qubits may be arranged in a linear array, a hexagonal array, and / or any other suitable shape). In various instances, such a quantum substrate may also include any suitable quantum control hardware, such as microwave resonators, waveguides, and / or any suitable signaling components (e.g., transmitters and / or receivers), which can send electrical and / or optical stimuli to actuate operations on the qubits and / or measure the qubits. That is, such quantum control hardware can be used to controllably change the state of the qubits. In any case, the quantum computing device 114 can facilitate quantum computing. That is, the quantum computing device 114 can apply any suitable quantum circuitry to any suitable quantum state in various instances.

[0061] In various instances, the runtime container and the quantum computing device 114 can be tightly coupled together, enabling low-latency electronic communication between them. For example, in some cases, the runtime container can be co-located with the quantum computing device 114. For instance, the runtime manager component 112 can spool the runtime container onto processor 106 and / or memory 108, and processor 106 and / or memory 108 can be physically located near the quantum computing device 114, allowing processor 106 and / or memory 108 to be physically wired to the quantum computing device 114. As another example, in some cases, the runtime container and the quantum computing device 114 can communicate with each other via a dedicated network channel. For example, although not explicitly shown in the figures, the runtime manager component 112 can spool the runtime container onto a computing machine (not shown) located away from the quantum computing device 114 but still coupled to it via a fixed-bandwidth wireless connection.

[0062] In various aspects, the runtime container and the quantum computing device 114 can work together to fully execute a computer program. More specifically, in various cases, the runtime container can classically execute the computer program. This classical execution allows the computer program to specify one or more quantum computations to be performed. In various instances, when the computer program specifies and / or otherwise requests the operation / execution of one or more such quantum computations, the runtime container can transmit instructions to the quantum computing device 114. These instructions can cause the quantum computing device 114 to electronically execute the one or more quantum computations. In various cases, the quantum computing device 114 can transmit the quantum results produced by the quantum computation back to the runtime container. In various aspects, the runtime container can continue and / or complete the classical execution of the computer program by utilizing such quantum results. Continuing and / or completing the classical execution of the computer program in this way can produce one or more program results.

[0063] In other words, the runtime container can be considered as facilitating classical instructions contained within a computer program, and the quantum computing device 114 can be considered as facilitating quantum instructions contained within a computer program. In either case, the backend quantum runtime system 102 can fully execute the computer program remotely from the client device 104 via the runtime container and the quantum computing device 114.

[0064] In various embodiments, the backend quantum runtime system 102 may include a recording component 116. In various aspects, the recording component 116 may electronically record, log, archive, maintain, and / or otherwise store quantum results generated by the quantum computing device 114 and / or program results generated by the runtime container. In various instances, the recording component 116 may include any suitable data structure (e.g., relational data structure, graph data structure, hybrid data structure). Furthermore, in various cases, the recording component 116 may record, log, archive, maintain, and / or otherwise store quantum results and / or program results in any suitable data format.

[0065] In various embodiments, the backend quantum runtime system 102 may include a transmitter component 118. In various aspects, the transmitter component 118 may electronically transmit any quantum results and / or program results stored by the recording component 116 to the client device 104.

[0066] Figure 2 A block diagram of an example, non-limiting system 200, including a computer program that facilitates backend quantum runtime, is shown according to one or more embodiments described herein. As shown, in some cases, system 200 may include the same components as system 100, and may also include computer program 202.

[0067] In various embodiments, receiver component 110 may electronically receive, retrieve, and / or access computer program 202 from client device 104. That is, client device 104 may electronically provide computer program 202 to receiver component 110. In various aspects, computer program 202 may be any suitable executable script including both classical computing instructions and quantum computing instructions. For example, computer program 202 may include a classical optimization loop, wherein each iteration of the classical optimization loop may involve classical computation, and wherein each iteration of the classical optimization loop may also invoke and / or otherwise request the operation / execution of quantum computation. As a non-limiting example, computer program 202 may be an executable script facilitating the execution of VQE and / or QAOA. (See also...) Figure 3 Let me explain this in more detail.

[0068] Figure 3 A block diagram of an example, non-limiting computer program incorporating quantum computing within a classical optimization loop, according to one or more embodiments described herein, is shown. In other words, Figure 3 Pseudocode depicting non-limiting and exemplary embodiments of computer program 202 is provided.

[0069] As shown, computer program 202 may include, in different instances, a set of computation instructions 302 configured to iteratively compute an optimized set of parameters (e.g., an optimized set of scalars, vectors, matrices, and / or tensors).

[0070] In various aspects, the set of computation instructions 302 may include computation instructions 304. In different cases, computation instructions 304 may request initialization and / or receive proposed parameters. As will be understood by those skilled in the art, proposed parameters can be considered as an initial and / or educated guess of the optimal parameter values ​​for which the computer program 202 is designed for iterative computation.

[0071] In different instances, the set of computation instructions 302 may include computation instructions 306. In different situations, computation instructions 306 may require the initialization and / or receipt of some convergence criteria. As those skilled in the art will understand, convergence criteria (e.g., cost function thresholds and / or loss function thresholds) may be used to continue and / or stop the iteration of computer program 202.

[0072] In various aspects, the set of computation instructions 302 may include computation instructions 308. In different cases, in this non-limiting example, computation instructions 308 may initiate a while loop. Thus, computation instructions nested within the while loop (e.g., 310-316) may iterate until a convergence criterion is met.

[0073] In various instances, the set of computation instructions 302 may include computation instructions 310. In various cases, computation instructions 310 may induce the establishment of a quantum state based on proposed parameters. In various cases, computation instructions 310 may involve any suitable quantum embedding technique (e.g., amplitude embedding) that can be implemented to convert proposed parameters into a quantum state (e.g., transforming proposed parameters into a quantum-processable format).

[0074] In various aspects, the set of computation instructions 302 may include computation instructions 312. In different contexts, computation instructions 312 may request and / or otherwise request the application of a quantum circuit to the quantum state established in computation instructions 310. In different contexts, this can be interpreted as requesting and / or requesting the performance of a quantum computation. In various contexts, the result of such a quantum computation may be referred to as a quantum result.

[0075] In different instances, the set of computation instructions 302 may include computation instructions 314. In different cases, computation instructions 314 may update and / or perturb the proposed parameters based on the quantum result. In different cases, computation instructions 314 may involve any suitable classical optimization technique for updating and / or perturbing the proposed parameters.

[0076] In various aspects, the set of computation instructions 302 may include computation instructions 316. In different cases, computation instructions 316 may cause a convergence criterion to be checked. Again, in different cases, the convergence criterion may be a threshold against which updated hypothetical parameters may be compared and / or a cost function and / or loss function based on updated hypothetical parameters may be compared with the threshold.

[0077] In different instances, this set of calculation instructions 302 may include calculation instruction 318. In different situations, calculation instruction 318 may terminate the while loop.

[0078] In various aspects, the set of calculation instructions 302 may include calculation instructions 320. In different cases, calculation instructions 320 may cause optimized hypothetical parameters (e.g., recently updated hypothetical parameters) to be output and / or provided.

[0079] As those skilled in the art will understand, the while loop of computer program 202 (e.g., computation instructions 308-318) is considered a classical optimization loop. This while loop can iterate until a convergence criterion is met. Furthermore, in different cases, computation instructions 312 can be considered as requesting and / or otherwise demanding the execution of quantum computation. Since computation instructions 312 are within a while loop, in this non-limiting example, computer program 202 can be considered as requesting quantum computation utilizing a classical optimization loop. In other words, computer program 202 can request the execution of quantum computation for each iteration of the while loop (e.g., for each iteration of a classical optimization loop).

[0080] Figure 4 A block diagram of an example, non-limiting system 400 including a runtime container that facilitates backend quantum runtime, according to one or more embodiments described herein, is shown. As illustrated, in some cases, system 400 may include the same components as system 200, and may also include runtime container 402 and / or quantum computing 404.

[0081] In different embodiments, runtime manager component 112 can electronically spool runtime container 402, which can electronically host computer program 202. Because backend quantum runtime system 102 can be remote from client device 104 (e.g., it can be in a backend environment such as a cloud environment, while client device 104 can be in a frontend environment), runtime container 402 can also be remote from client device 104 (e.g., it can also be in a backend environment).

[0082] In various cases, as described above, runtime container 402 can be any suitable software container according to any suitable containerized application delivery paradigm (e.g., it can be a Docker® container, a Kubernetes® container, and / or a containerd container). In different cases, computer program 202 can be considered a software image that can be implemented and / or executed by runtime container 402. Although not explicitly shown in the figures, in some cases, client device 104 may transmit to receiver component 110 instructions regarding one or more software libraries and / or software packages upon which computer program 202 depends. Thus, in such cases, runtime container 402 can download and / or otherwise install such software libraries from any suitable data structure (not shown) that is electronically accessible to runtime container 402.

[0083] In various respects, as described above, the runtime container 402 and the quantum computing device 114 can be tightly coupled together, enabling low-latency electronic transmissions between the runtime container 402 and the quantum computing device 114. As an example, the runtime container 402 can be placed side-by-side with the quantum computing device 114. For instance, the runtime container 402 can be spooled onto a computing machine (e.g., on processor 106 and / or memory 108), and this computing machine can be physically located close to the quantum computing device 114, allowing the computing machine and the quantum computing device 114 to be physically wired together. As another example, the runtime container 402 and the quantum computing device 114 can communicate with each other via any suitable dedicated electronic communication channel. For example, although not explicitly shown in these figures, the runtime container 402 can be spooled onto a computing machine remote from the quantum computing device 114 but still coupled to the quantum computing device 114 via a fixed-bandwidth wireless network connection.

[0084] In various respects, runtime container 402 and quantum computing device 114 can cooperate to fully execute computer program 202. For example, runtime container 402 can classically execute computer program 202. In other words, runtime container 402 can execute / process any classical instructions contained within computer program 202. This classical execution can cause computer program 202 to request and / or otherwise specify one or more quantum computations 404 to be performed. As mentioned above, computer program 202 can request quantum computation by specifying and / or otherwise instructing that a given quantum circuit should be applied to a given quantum state. In various instances, runtime container 402 can electronically instruct, command, and / or otherwise cause quantum computing device 114 to perform the one or more quantum computations 404. Therefore, quantum computing device 114 can execute / process any quantum instructions contained within computer program 202.

[0085] Figure 5 A block diagram of an example, non-limiting system 500, comprising quantum results and / or procedural results that facilitate backend quantum runtime, is shown according to one or more embodiments described herein. As illustrated, in some cases, system 500 may include the same components as system 400 and may further include quantum result 502 and / or procedural result 504.

[0086] As described above, the quantum computing device 114 can perform one or more quantum computations 404. In different cases, this can produce one or more quantum results 502, each corresponding to one or more quantum computations 404. In different instances, each of the one or more quantum results 502 can be a resulting quantum state generated by the quantum computing device 114 based on a corresponding quantum computation among the one or more quantum computations 404. In various aspects, the one or more quantum results 502 can be electronically stored and / or maintained by the recording component 116.

[0087] In various aspects, runtime container 402 can retrieve one or more quantum results 502 from quantum computing device 114 (and / or from recording component 116). In various cases, runtime container 402 can continue and / or complete the classical execution of computer program 202 by utilizing one or more quantum results 502. In various cases, this can produce one or more program results 504. In various instances, each of the one or more program results 504 can be a scalar, vector, matrix, and / or tensor, which is computed by runtime container 402 based on a corresponding one of the one or more quantum results 502. In various aspects, one or more program results 504 can be electronically stored and / or maintained by recording component 116.

[0088] To help clarify some of the points in this discussion, let's reconsider... Figure 3 The computer program 202 shown is a non-limiting example. In various cases, computation instructions 304-310 can be considered classical instructions. Therefore, runtime container 402 can execute them electronically. That is, runtime container 402 can: initialize and / or otherwise obtain the proposed parameters according to computation instruction 304; initialize and / or otherwise obtain the convergence criterion according to computation instruction 306; start a while loop according to computation instruction 308, which iterates as long as the proposed parameters do not satisfy the convergence criterion; and compute and / or otherwise compute the quantum state based on the proposed parameters according to computation instruction 310.

[0089] In various respects, computation instruction 312 can be considered a quantum instruction rather than a classical instruction because it involves applying a quantum circuit to a quantum state established in computation instruction 310. This application of a quantum circuit to a quantum state can be considered as one of one or more quantum computations 404. Therefore, runtime container 402 cannot electronically execute computation instruction 312 on its own. However, runtime container 402 can electronically instruct quantum computing device 114 to apply a quantum circuit to a quantum state, which can produce a quantum result (e.g., one of the one or more quantum results 502). More specifically, in response to such an instruction, quantum computing device 114 can initialize its qubits, thereby bringing the qubits into the quantum state specified by computation instruction 310. Furthermore, quantum computing device 114 can then transform the state of its qubits according to the quantum circuit specified in computation instruction 312. The resulting quantum state of the qubits of quantum computing device 114 can be considered as the quantum result obtained in computation instruction 312.

[0090] In different contexts, computation instructions 314-316 can be considered classical instructions. Therefore, runtime container 402 can execute them electronically. That is, runtime container 402 can: update the proposed parameters based on quantum results according to computation instruction 314, via any suitable classical optimization and / or perturbation techniques; and can check whether the updated proposed parameters satisfy the convergence criterion. If yes, runtime container 402 can terminate the while loop according to computation instruction 318 and proceed to computation instruction 320. If no, runtime container 402 can return to computation instruction 310 to execute another iteration of the while loop.

[0091] Therefore, as explained above, runtime container 402 can be considered to facilitate classical instructions (e.g., 304-310 and 314-320) contained within computer program 202, and quantum computing device 114 can be considered to facilitate quantum instructions (e.g., 312) contained within computer program 202. In any case, runtime container 402 and quantum computing device 114 can work together to fully execute computer program 202 remotely from client device 104 (e.g., to fully execute computer program 202 in a backend and / or cloud environment).

[0092] Figure 6 A flowchart illustrating an example, non-limiting computer implementation of method 600 that facilitates a backend quantum runtime according to one or more embodiments described herein is shown. In various instances, the computer implementation of method 600 may be facilitated by a backend quantum runtime system 102.

[0093] In different embodiments, action 602 may include a computer program (e.g., 202) received by a backend service (e.g., 110) that requires quantum computing (e.g., 312) for classical optimization loops (e.g., 308-318).

[0094] In various aspects, action 604 may include a spooled runtime container (e.g., 402) used by a backend service (e.g., 112) to host a computer program.

[0095] In various examples, action 606 may include initializing i = 1 by the runtime container. Those skilled in the art will understand that in this non-limiting example, i may be a dummy index that helps facilitate iteration.

[0096] In various cases, action 608 may include the i-th iteration of a classically optimized loop executed classically by a runtime container. In various instances, this may allow the computer program to specify and / or otherwise require the performance of the i-th quantum computation (e.g., one of 404). In various cases, such quantum computation may take the form of applying a specified quantum circuit to a specified quantum state.

[0097] In various aspects, action 610 may include a quantum computer (e.g., 114) instructed by the runtime container to perform the i-th quantum computation. In different cases, this may produce the i-th quantum result (e.g., one of 502).

[0098] In different cases, action 612 may include the i-th iteration of a classical optimization loop of a computational program performed by the runtime container by utilizing the i-th quantum result. In different cases, this may produce the i-th program result (e.g., one of 504).

[0099] In different cases, action 614 may include determining, by the runtime container, whether the result of the i-th program has met the convergence criterion (e.g., 316). If yes, the computer-implemented method 600 may proceed to action 616. If no, the computer-implemented method 600 may proceed to action 618.

[0100] In various aspects, action 616 may include (for example, ending the computer-implemented method 600 by outputting the result of the i-th program as the final and / or optimized result calculated by the computer program).

[0101] In different instances, action 618 may include updating parameters of the computer program by the runtime container based on the result of the i-th program (e.g., 314). In different cases, the computer-implemented method 600 may subsequently return to action 608.

[0102] Figure 7A communication diagram of an example, non-limiting workflow 700, which can facilitate backend quantum runtime according to one or more embodiments described herein, is shown. In other words, Figure 7 This document provides non-restrictive examples of how the various components described in this article can interact with each other.

[0103] In various embodiments, the client device 104 can electronically transmit the computer program 202 to the backend quantum runtime system 102 in action 702.

[0104] In various respects, the runtime manager component 112 can electronically instantiate the runtime container 402 in action 704 to host the computer program 202.

[0105] Next, under different circumstances, runtime container 402 and quantum computing device 114 can cooperate to fully execute computer program 202 remotely from client device 104. Such cooperation can take the form of iterative interactions under different circumstances. Suppose that computer program 202 is configured to iterate n times for any suitable positive integer n. In this case, runtime container 402 and quantum computing device 114 can participate in n iterative interactions, where the first iteration is denoted as action 706(1), and the nth iteration is denoted as action 706(n).

[0106] During the first iterative interaction (e.g., during the first iteration of computer program 202), runtime container 402 may begin classical execution of computer program 202 at action 706(1)(a). In various cases, this may allow computer program 202 to specify, instruct, and / or otherwise request the operation / execution of one or more quantum computations 404. Runtime container 402 may then electronically instruct quantum computing device 114 to perform such quantum computation at action 706(1)(b). In various instances, quantum computing device 114 may facilitate and / or otherwise perform quantum computation at action 706(1)(c), thereby producing one or more quantum results 502. In various cases, quantum computing device 114 may then electronically transfer such quantum results back to runtime container 402 at action 706(1)(d). In various aspects, runtime container 402 may complete the first iteration of computer program 202 at action 706(1)(e), thereby producing one or more program results 504.

[0107] The runtime container 402 and / or quantum computing device 114 can then move to the next iteration, as illustrated by action 706(n). Those skilled in the art will understand that action 706(n) is similar to action 706(1).

[0108] In all respects, once all n iterations of computer program 202 have been completed, in action 708, runtime container 402 can electronically transfer the final result (and / or in some cases, intermediate result) produced by computer program 202 to client device 104.

[0109] As explained herein, runtime container 402 can be tightly bound to quantum computing device 114 (e.g., it can be co-located, it can have a dedicated communication connection). Such tight binding can result in low latency (e.g., not consuming excessive time) for each of the n iterative interactions between runtime container 402 and quantum computing device 114. Conversely, client device 104 can be not tightly bound to any component of the backend quantum runtime system 102. This lack of tight binding can make each interaction between client device 104 and backend quantum runtime system 102 consume more time than any interaction between runtime container 402 and quantum computing device 114. Note that if the prior art is implemented, then in Figure 7 There is no runtime manager component 112 in this case. Instead, if the prior art is implemented, all n iterations of interaction will occur between the client device 104 and the quantum computing device 114. Since the client device 104 is not tightly bound to the quantum computing device 114, each of such n iterations of interaction can be highly latency-intensive. For large n, this means that the prior art consumes significantly more time compared to the various embodiments of the backend quantum runtime system 102 as described herein. In other words, the backend quantum runtime system 102 can significantly reduce the latency associated with existing remote quantum computing services and thus constitutes a concrete and tangible technological improvement in the field of quantum computing.

[0110] Most of the above discussion describes how various embodiments of the backend quantum runtime system 102 can fully execute computer programs 202 in a backend (e.g., cloud) environment using runtime container 402 and quantum computing device 114. However, in various embodiments, the backend quantum runtime system 102 may include multiple quantum computing devices and / or may spool multiple runtime containers to host multiple computer programs provided by multiple client devices. In other words, although the figures depict only a single client device 104, this is a non-limiting example for simplicity. In various cases, any appropriate number of client devices 104 may electronically transmit any appropriate number of computer programs to receiver component 110 simultaneously and / or in an interleaved manner. In fact, in some cases, client devices may electronically transmit more than one computer program to receiver component 110. Similarly, although the figures depict only a single runtime container 402, this is a non-limiting example for simplicity. In various aspects, runtime manager component 112 may electronically spool any appropriate number of runtime containers. For example, runtime manager component 112 can electronically instantiate a runtime container for each computer program received by receiver component 110. Furthermore, any suitable number of such runtime containers can operate in parallel with each other after being spooled. Similarly, although the figures depict only a single quantum computing device 114, this is a non-limiting example for simplicity. In various instances, the backend quantum runtime system 102 can include any suitable number of quantum computing devices. In fact, in different cases, runtime containers spooled by runtime manager component 112 can collectively apply load balancing across any suitable number of such quantum computing devices to always maximize quantum computing.

[0111] Much of the above discussion describes how, in various embodiments, the runtime manager component 112 can host the computer program 202 via a spooled runtime container 402, wherein the runtime container 402 can be tightly bound to the quantum computing device 114, wherein the runtime container 402 can execute any classical portion of the computer program 202, and wherein the runtime container 402 can command the quantum computing device 114 to execute any quantum portion of the computer program 202. However, it should be understood that this is merely a non-limiting example. In various other embodiments, the runtime manager component 112 can spool and / or instantiate any suitable backend classical computing resource to host the computer program 202. In various cases, the backend classical computing resource can be tightly bound to the quantum computing device 114, can execute any classical portion of the computer program 202, and can command the quantum computing device 114 to execute any quantum portion of the computer program 202. In various aspects, the backend classical computing resource can exhibit any suitable software design and / or architecture capable of executing the software application. For example, different non-limiting examples of such backend classic computing resources may include containers (e.g., runtime container 402), virtual machines, and / or software deployed on bare metal computers. In other words, runtime manager component 112 may, in various respects, spool and / or instantiate any suitable piece of computer software capable of hosting and / or otherwise executing the computer program 202 as described herein.

[0112] In various embodiments, it may be desirable to allow client device 104 to communicate, interact with, and / or otherwise monitor computer program 202 while runtime container 402 hosts computer program 202. Similarly, in some cases, it may be desirable to allow client device 104 to communicate, interact with, and / or otherwise monitor quantum computing device 114 while runtime container 402 hosts computer program 202. Therefore, in various aspects, runtime manager component 112 may mediate communication / interaction between client device 104, computer program 202, and / or quantum computing device 114. For example, in various cases, client device 104 may transmit commands / instructions regarding computer program 202 and / or regarding quantum computing device 114 to runtime manager component 112 in real time, and runtime manager component 112 may execute and / or follow such commands / instructions. Non-limiting examples of such commands / instructions may include initiating the execution of computer program 202, stopping the execution of computer program 202, editing computer program 202, specifying desired characteristics and / or desired settings for runtime container 402, specifying desired characteristics and / or desired settings for quantum computing device 114, and / or specifying desired results to be retrieved from recording component 116. Other non-limiting examples of such commands / instructions may include firewalls and / or rate limiting in different contexts. In the case of implementing multiple client devices, multiple computer programs, and / or multiple quantum computing devices, such commands / instructions may further include: modifying communication settings between client devices, computer programs, and / or quantum computing devices to implement isolation between client devices, to implement trust domains between client devices and quantum computing devices, to provide fair shared access to quantum computing devices and / or instantiated backend classical computing resources, and / or to provide different service levels (e.g., different quantum resources and / or classical resources) to different client devices based on client workload.

[0113] Figure 8 A flowchart illustrating an example, non-limiting computer implementation method 800 that can facilitate a backend quantum runtime according to one or more embodiments described herein is shown. In various aspects, the computer implementation method 800 can be facilitated by a backend quantum runtime system 102.

[0114] In various embodiments, action 802 may include accessing a computer program (e.g., computer program 202) provided by a client device (e.g., client device 104) via a back-end device operatively coupled to the processor (e.g., via receiver component 110). In various cases, the computer program may be configured to instruct quantum computing (e.g., one of one or more quantum computing units 404).

[0115] In different instances, action 804 may include hosting a computer program by a backend device (e.g., via runtime manager component 112) by instantiating a backend classical computing resource (e.g., runtime container 402). In different cases, the backend classical computing resource may orchestrate both classical execution of the computer program and quantum execution of quantum computing instructed by the computer program.

[0116] Despite Figure 8 It is not explicitly shown that the computer implementation method 800 may further include: performing quantum computing on at least one back-end quantum computing device (e.g., via quantum computing device 114) by a back-end device and in response to instructions from a back-end classical computing resource.

[0117] Despite Figure 8 It is not explicitly shown that, during execution by backend classical computing resources, the computer program may utilize quantum results generated by at least one backend quantum computing device (e.g., 502) to produce program results (e.g., 504).

[0118] Although Figure 8 Not explicitly shown, but the computer implementation method 800 may further include recording quantum results or program results via a back-end device (e.g., via recording component 116).

[0119] Despite Figure 8 It is not explicitly shown, but backend classical computing resources and at least one backend quantum computing device can be placed side by side and / or can be coupled via a dedicated communication channel.

[0120] Despite Figure 8 It is not explicitly stated that backend classic computing resources can be runtime containers.

[0121] Despite Figure 8 It is not explicitly stated that backend classical computing resources can mediate communication between client devices and computer programs.

[0122] Although Figure 8 Not explicitly shown, but the computer implementation method 800 may further include: accessing another computer program provided by another client device by a backend device (e.g., via receiver component 110), wherein the other computer program is configured to instruct another quantum computation; and hosting the other computer program by the backend device (e.g., via runtime manager component 112) by instantiating another backend classical computing resource, wherein the other backend classical computing resource orchestrates both classical execution of the other computer program and quantum execution of the other quantum computation instructed by the other computer program, and wherein the other backend classical computing resource operates in parallel with the other backend classical computing resource.

[0123] Complex quantum applications may require combining quantum processing resources with classical processing resources. Indeed, the quantum computing field has seen an increase in algorithms that invoke quantum computation within classical optimization loops (e.g., VQE and / or QAOA). For efficient execution of such algorithms, the interaction between quantum and classical processing resources should have relatively low latency. Existing remote quantum computing services (e.g., cloud servers providing quantum computing as a service) experience increased latency due to their bifurcated service architectures. In such existing systems, users utilize their own classical processors (e.g., laptops running Qiskits) to create and execute computer programs that require quantum computation. When the computer program requests quantum computation (e.g., when the computer program specifies a quantum circuit to be applied to a certain quantum state), the user sends instructions to a remote quantum computing service to perform the specified quantum computation. The user must then wait to receive the quantum result from the remote quantum computing service. For computer programs involving many iterations, such waits accumulate rapidly, which can be undesirable.

[0124] Various embodiments of the present invention can solve this technical problem. The inventors recognize that the high latency of the prior art is caused by a severe bifurcation between classical computing resources on the user side and quantum computing resources on the server side. Therefore, the inventors have designed different embodiments of the present invention, wherein both classical computing resources and quantum computing resources are provided on the server side. In practice, in the different embodiments, the remote quantum computing service does not simply receive requests to perform quantum computing, but rather receives and hosts an entire computer program configured to generate requests for quantum computing. Because, according to the different embodiments, the computer program can be hosted and therefore classically executed on the server side, such classical execution can be more tightly coupled and / or bundled to the quantum computing resources on the server side. Thus, when implementing the different embodiments of the present invention, the iterative computer program requesting the running / execution of quantum computing can be executed more quickly. In other words, since the different embodiments of the present invention eliminate the bottleneck inherent in existing remote quantum computing services, a significant reduction in latency can be achieved.

[0125] To provide additional context for the various embodiments described herein, Figure 9 The following discussion is intended to provide a brief, general description of a suitable computing environment 900 in which various embodiments of the embodiments described herein may be implemented. While the embodiments have been described above in the general context of computer-executable instructions that can run on one or more computers, those skilled in the art will recognize that the embodiments may also be implemented in combination with other program modules and / or as a combination of hardware and software.

[0126] Typically, program modules include routines, programs, components, data structures, etc., that perform specific tasks or implement specific abstract data types. Furthermore, those skilled in the art will recognize that the methods of this invention can be practiced with other computer system configurations, including single-processor or multi-processor computer systems, minicomputers, mainframe computers, Internet of Things (IoT) devices, distributed computing systems, and personal computers, handheld computing devices, microprocessor-based or programmable consumer electronics, each of which can be operatively coupled to one or more associated devices.

[0127] The embodiments illustrated in this document can also be implemented in a distributed computing environment, where some tasks are performed by remote processing devices linked via a communication network. In a distributed computing environment, program modules can reside on both local and remote storage devices.

[0128] Computing devices typically include a variety of media, which may include computer-readable storage media, machine-readable storage media, and / or communication media, these two terms being used differently from each other herein. A computer-readable storage medium or a machine-readable storage medium can be any available storage medium accessible by a computer, and includes volatile and non-volatile media, removable and non-removable media. By way of example and not limitation, a computer-readable storage medium or a machine-readable storage medium can be implemented using any method or technique for storing information such as computer-readable or machine-readable instructions, program modules, structured data, or unstructured data.

[0129] Computer-readable storage media may include, but are not limited to: random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD-ROM), digital universal disc (DVD), Blu-ray disc (BD) or other optical disc storage, magnetic tape cassettes, magnetic tape, disk storage or other magnetic storage devices, solid-state drives or other solid-state storage devices, or other tangible and / or non-transient media that can be used to store desired information. In this regard, the terms “tangible” or “non-transient” as used herein with respect to storage, memory, or computer-readable media shall be understood to exclude only the propagation of transient signals themselves as a modifier, and shall not waive the rights to all standard storage, memory, or computer-readable media that do not only propagate transient signals themselves.

[0130] A computer-readable storage medium can be accessed by one or more local or remote computing devices, for example via access requests, queries or other data retrieval protocols, for various operations with respect to the information stored in the medium.

[0131] Communication media typically embody computer-readable instructions, data structures, program modules, or other structured or unstructured data as data signals such as modulated data signals (e.g., carrier waves or other transmission mechanisms), and include any information delivery or transmission medium. The term "modulated data signal" refers to a signal whose characteristics are set or altered in a manner that encodes information in one or more signals. By way of example and not limitation, communication media include wired media, such as wired networks or direct-line connections, and wireless media, such as acoustic, RF, infrared, and other wireless media.

[0132] Refer again Figure 9 An example environment 900 for implementing various embodiments of the aspects described herein includes a computer 902, which includes a processing unit 904, system memory 906, and a system bus 908. The system bus 908 couples system components, including but not limited to the system memory 906, to the processing unit 904. The processing unit 904 can be any of different commercially available processors. Dual microprocessors and other multiprocessor architectures can also be used as the processing unit 904.

[0133] System bus 908 can be any of several types of bus structures that can be further interconnected to a memory bus (with or without a memory controller), a peripheral bus, and a local bus using any of a variety of commercially available bus architectures. System memory 906 includes ROM 910 and RAM 912. The Basic Input / Output System (BIOS) can be stored in non-volatile memory such as ROM, erasable programmable read-only memory (EPROM), or EEPROM. The BIOS contains basic routines such as those that help transfer information between components within computer 902 during startup. RAM 912 may also include high-speed RAM, such as static RAM for caching data.

[0134] Computer 902 further includes an internal hard disk drive (HDD) 914 (e.g., EIDE, SATA), one or more external storage devices 916 (e.g., floppy disk drive (FDD) 916, memory stick or flash drive reader, memory card reader, etc.), and a drive 920 (e.g., solid-state drive, optical disc drive) that can read from or write to a disk 922 (e.g., CD-ROM, DVD, BD, etc.). Alternatively, in cases involving solid-state drives, disk 922 will not be included unless it is separate. Although the internal HDD 914 is shown as being located within computer 902, the internal HDD 914 may also be configured for external use in a suitable rack (not shown). Additionally, although not shown in environment 900, a solid-state drive (SSD) may be used as a supplement to or replacement for the HDD 914. The HDD 914, external storage devices 916, and drive 920 may be connected to system bus 908 via HDD interface 924, external storage interface 926, and drive interface 928, respectively. The interface 924 for the external driver implementation may include at least one or both of Universal Serial Bus (USB) and Institute of Electrical and Electronics Engineers (IEEE) 1394 interface technologies. Other external driver connectivity technologies are contemplated in the embodiments described herein.

[0135] The drive and its associated computer-readable storage medium provide non-volatile storage of data, data structures, computer-executable instructions, etc. For computer 902, the drive and storage medium accommodate any data stored in a suitable digital format. Although the above description of computer-readable storage media refers to a corresponding type of storage device, those skilled in the art will understand that other types of computer-readable storage media (whether currently existing or developed in the future) may also be used in the example operating environment, and further, any such storage medium may contain computer-executable instructions for performing the methods described herein.

[0136] Multiple program modules may be stored in the drive and RAM 912, including an operating system 930, one or more application programs 932, other program modules 934, and program data 936. All or part of the operating system, applications, modules, and / or data may also be cached in RAM 912. The systems and methods described herein can be implemented using different commercially available operating systems or combinations of operating systems.

[0137] Computer 902 may optionally include emulation technology. For example, a hypervisor (not shown) or other intermediary may emulate the hardware environment of operating system 930, and the emulated hardware may optionally be compatible with... Figure 9The hardware shown is different. In such an embodiment, the operating system 930 may include one of a plurality of virtual machines (VMs) hosted at the computer 902. Furthermore, the operating system 930 may provide a runtime environment for the application 932, such as the Java Runtime Environment or the .NET Framework. A runtime environment is a consistent execution environment that allows the application 932 to run on any operating system that includes a runtime environment. Similarly, the operating system 930 may support containers, and the application 932 may be in the form of a container, which is a lightweight, standalone, executable software package including, for example, code, runtime, system tools, system libraries, and settings for the application.

[0138] Furthermore, computer 902 can enable security modules, such as Trusted Processing Modules (TPMs). For example, with TPMs, before loading the next boot component, the boot component performs a three-column check on the next boot component in time and waits for the result to match with a security value. This process can occur at any layer of computer 902's code execution stack, such as at the application execution level or at the operating system (OS) kernel level, thereby achieving security at any code execution level.

[0139] Users can input commands and information into computer 902 through one or more wired / wireless input devices (e.g., keyboard 938, touchscreen 940, and pointing devices such as mouse 942). Other input devices (not shown) may include microphones, infrared (IR) remote controls, radio frequency (RF) remote controls, or other remote controls, joysticks, virtual reality controllers and / or virtual reality headsets, game controllers, styluses, image input devices (e.g., cameras), gesture sensor input devices, visual motion sensor input devices, emotion or face detection devices, biometric input devices (e.g., fingerprint or iris scanners), or the like. These and other input devices are often connected to processing unit 904 via input device interface 944, which can be coupled to system bus 908, but can be connected via other interfaces such as parallel ports, IEEE 1394 serial ports, game ports, USB ports, IR interfaces, BLUETOOTH® interfaces, etc.

[0140] The monitor 946 or other types of display devices can also be connected to the system bus 908 via an interface such as the video adapter 948. In addition to the monitor 946, the computer typically includes other peripheral output devices (not shown), such as speakers, printers, etc.

[0141] Computer 902 can operate in a networked environment using logical connections via wired and / or wireless communications to one or more remote computers, such as remote computer 950. Remote computer 950 can be a workstation, server computer, router, personal computer, laptop computer, microprocessor-based entertainment device, peer-to-peer device, or other public network node, and typically includes many or all of the elements described relative to computer 902; however, for brevity, only memory / storage device 952 is shown. The depicted logical connections include wired / wireless connections to a local area network (LAN) 954 and / or a larger network (e.g., a wide area network (WAN) 956). Such LAN and WAN networking environments are common in offices and companies and facilitate enterprise-wide computer networks, such as intranets, all of which can connect to global communication networks, such as the Internet.

[0142] When used in a LAN networking environment, computer 902 can connect to local network 954 via a wired and / or wireless communication network interface or adapter 958. Adapter 958 facilitates wired or wireless communication to LAN 954, which may also include a wireless access point (AP) deployed thereon for communicating with adapter 958 in wireless mode.

[0143] When used in a WAN networking environment, computer 902 may include modem 960 or a communication server on WAN 956 that can be connected via other means (such as via the Internet) for establishing communication over WAN 956. Modem 960, which may be internal or external and wired or wireless, may be connected to system bus 908 via input device interface 944. In a networking environment, program modules depicted relative to computer 902 or parts thereof may be stored in remote memory / storage device 952. It should be understood that the network connection shown is an example, and other means of establishing communication links between computers may be used.

[0144] When used in a LAN or WAN networking environment, computer 902 can access cloud storage systems or other network-based storage systems as a supplement to or replacement of the external storage device 916 as described above, such as, but not limited to, network virtual machines providing one or more aspects of information storage or processing. Typically, the connection between computer 902 and the cloud storage system can be established, for example, via adapter 958 or modem 960 through LAN 954 or WAN 956. When computer 902 is connected to the associated cloud storage system, external storage interface 926 can manage the storage provided by the cloud storage system by means of adapter 958 and / or modem 960, just like other types of external storage. For example, external storage interface 926 can be configured to provide access to cloud storage sources as if those sources were physically connected to computer 902.

[0145] Computer 902 can operatively communicate with any wireless device or entity operatively arranged in wireless communication, such as a printer, scanner, desktop and / or laptop computer, portable data assistant, communication satellite, any device or location associated with a wirelessly detectable tag (e.g., a kiosk, newsstand, store shelf, etc.), and telephone. This can include Wi-Fi and BLUETOOTH® wireless technologies. Thus, communication can be a predefined structure like an existing network, or simply self-organizing communication between at least two devices.

[0146] See now Figure 10 This describes an illustrative cloud computing environment 1000. As shown, the cloud computing environment 1000 includes one or more cloud computing nodes 1002 that can communicate with local computing devices used by cloud consumers, such as personal digital assistants (PDAs) or cellular phones 1004, desktop computers 1006, laptop computers 1008, and / or automotive computer systems 1010. The nodes 1002 can communicate with each other. They can be physically or virtually grouped (not shown) in one or more networks, such as private clouds, community clouds, public clouds, or hybrid clouds, or combinations thereof, as described above. This allows the cloud computing environment 1000 to provide infrastructure, platforms, and / or software as services that cloud consumers do not need to maintain on their local computing devices. It should be understood that... Figure 10 The types of computing devices 1004-1010 shown are intended to be illustrative only, and computing node 1002 and cloud computing environment 1000 can communicate with any type of computerized device via any type of network and / or network-addressable connection (e.g., using a web browser).

[0147] See now Figure 11 This demonstrates the 1000 cloud computing environment ( Figure 10This provides a set of functional abstraction layers. For the sake of brevity, repeated descriptions of similar elements used in other embodiments described herein are omitted. It should be understood in advance that... Figure 11 The components, layers, and functions shown are intended to be illustrative only, and embodiments of the invention are not limited thereto. As described, the following layers and corresponding functions are provided.

[0148] The hardware and software layer 1102 includes hardware and software components. Examples of hardware components include: a mainframe 1104; a server 1106 based on a RISC (Reduced Instruction Set Computer) architecture; a server 1108; a blade server 1110; a storage device 1112; and a network and networking component 1114. In some embodiments, the software components include network application server software 1116 and database software 1118.

[0149] The virtualization layer 1120 provides an abstraction layer from which the following examples of virtual entities can be provided: virtual server 1122; virtual storage 1124; virtual network 1126, including virtual private network; virtual application and operating system 1128; and virtual client 1130.

[0150] In one example, management layer 1132 may provide the functionality described below. Resource Provisioning 1134 provides dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and Pricing 1136 provides cost tracking as resources are utilized within the cloud computing environment and bills or invoices for the consumption of these resources. In one example, these resources may include application software licenses. Security provides authentication for cloud consumers and tasks, as well as protection for data and other resources. User Portal 1138 provides access to the cloud computing environment for consumers and system administrators. Service Level Management 1140 provides cloud resource allocation and management to ensure that required service levels are met. Service Level Agreement (SLA) Planning and Fulfillment 1142 provides pre-scheduling and procurement of cloud resources, anticipating future requirements for those resources according to the SLA.

[0151] Workload layer 1144 provides examples of functionalities that can leverage a cloud computing environment. Examples of workloads and functionalities that can be provided from this layer include: mapping and navigation 1146; software development and lifecycle management 1148; virtual classroom education delivery 1150; data analytics and processing 1152; transaction processing 1154; and differentiated private federated learning processing 1156. Various embodiments of the present invention can be utilized with reference to [reference needed]. Figure 10 and Figure 11 The cloud computing environment described herein is used to execute one or more differentiated private federated learning processes according to different embodiments described herein.

[0152] This invention can be a system, method, apparatus, and / or computer program product at any possible level of technical detail integration. A computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions thereon for causing a processor to execute aspects of the invention. A computer-readable storage medium may be a tangible means capable of retaining and storing instructions for use by an instruction execution device. A computer-readable storage medium may be, for example, but not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination thereof. A non-exhaustive list of more specific examples of computer-readable storage media may also include: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital universal disk (DVD), memory sticks, floppy disks, mechanical encoding devices such as punch cards, or protrusions in slots having instructions recorded thereon, and any suitable combination thereof. As used herein, computer-readable storage media should not be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through fiber optic cables), or electrical signals transmitted through wires.

[0153] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network), or downloaded to an external computer or external storage device. The network may include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to a computer-readable storage medium within the corresponding computing / processing device. The computer-readable program instructions used to perform the operations of this invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, status setting data, integrated circuit configuration data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​(such as Smalltalk, C++, etc.) and procedural programming languages ​​(such as the "C" programming language or similar programming languages). Computer-readable program instructions may execute entirely on a user's computer, partially on a user's computer, as a standalone software package, partially on a user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, a field-programmable gate array (FPGA), or a programmable logic array (PLA) may be personalized to execute computer-readable program instructions by utilizing state information of the computer-readable program instructions in order to perform aspects of the present invention.

[0154] The present invention will now be described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions. These computer-readable program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams. These computer-readable program instructions can also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner, such that the computer-readable storage medium storing the instructions comprises an article of manufacture containing instructions for implementing aspects of the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams. Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operations to be performed on the computer, other programmable apparatus, or other device to produce computer-implemented processing, such that the instructions executed on the computer, other programmable apparatus, or other device perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

[0155] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. Each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the blocks may occur in a different order than indicated in the figures. For example, depending on the functions involved, two consecutively shown blocks may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or action or executes a combination of dedicated hardware and computer instructions.

[0156] While the subject matter has been described above in the general context of computer-executable instructions running on a computer and / or a computer program product on a computer, those skilled in the art will recognize that this disclosure can also be implemented in combination with other program modules. Typically, program modules include routines, programs, components, data structures, etc., that perform specific tasks and / or implement specific abstract data types. Furthermore, those skilled in the art will recognize that the computer implementation methods of the present invention can be practiced with other computer system configurations, including single-processor or multi-processor computer systems, small computing devices, mainframe computers, and computers, handheld computing devices (e.g., PDAs, telephones), microprocessor-based or programmable consumer or industrial electronic products, etc. The aspects shown can also be implemented in a distributed computing environment, where tasks are performed by remote processing devices linked via a communication network. However, some (if not all) aspects of this disclosure can be practiced on a standalone computer. In a distributed computing environment, program modules can reside in both local and remote memory storage devices.

[0157] As used herein, the terms “component,” “system,” “platform,” “interface,” etc., may refer to and / or include computer-related entities or entities associated with an operating machine having one or more specific functions. Entities disclosed herein may be hardware, a combination of hardware and software, software, or software in execution. For example, a component may be, but is not limited to, a process running on a processor, a processor, an object, an executable file, a thread of execution, a program, and / or a computer. As an illustration, both an application running on a server and the server itself can be components. One or more components may reside within a process and / or a thread of execution, and components may reside on a single computer and / or be distributed across two or more computers. In another instance, a corresponding component may be executed from a different computer-readable medium having different data structures stored thereon. Components may communicate via local and / or remote processes, such as according to a signal having one or more data packets (e.g., data from a component interacting with another component in a local system, a distributed system, and / or data from a component interacting with other systems across a network such as the Internet via that signal). As another example, a component may be a device having specific functions provided by mechanical parts operated by electrical or electronic circuitry, which is operated by a software or firmware application executed by a processor. In such a case, the processor can be internal or external to the device and can execute at least a portion of the software or firmware application. As another example, the component can be a device that provides a specific function through electronic components without mechanical parts, wherein the electronic components can include a processor or other means for performing software or firmware that at least partially imparts the functionality to the electronic components. In one aspect, the component can be simulated via a virtual machine, for example, within a cloud computing system.

[0158] Furthermore, the term "or" is intended to mean an inclusive "or" rather than an exclusive "or". That is, unless otherwise specified or clear from the context, "X adopts A or B" is intended to mean any natural inclusive permutation. That is, if X adopts A; X adopts B; or X adopts both A and B, then "X adopts A or B" is satisfied in any of the foregoing cases. Additionally, the articles "a" and "an" as used in this specification and the accompanying drawings should generally be interpreted as meaning "one or more" unless otherwise specified or clearly indicated from the context to the singular form. As used herein, the terms "example" and / or "exemplary" are used to indicate that something is used as an example, instance, or illustration. To avoid doubt, the subject matter disclosed herein is not limited to such examples. Furthermore, any aspect or design described herein as "example" and / or "exemplary" is not necessarily to be construed as superior to or superior to other aspects or designs, nor does it imply the exclusion of equivalent exemplary structures and techniques known to those skilled in the art.

[0159] As used herein, the term "processor" can refer to substantially any computing processing unit or device, including but not limited to a single-core processor; a single processor with software multithreading capabilities; a multi-core processor; a multi-core processor with software multithreading capabilities; a multi-core processor with hardware multithreading technology; a parallel platform; and a parallel platform with distributed shared memory. Additionally, "processor" can refer to an integrated circuit, application-specific integrated circuit (ASIC), digital signal processor (DSP), field-programmable gate array (FPGA), programmable logic controller (PLC), complex programmable logic device (CPLD), discrete gate or transistor logic, discrete hardware components, or any combination thereof, designed to perform the functions described herein. Furthermore, processors can utilize nanoscale architectures, such as, but not limited to, molecular and quantum dot-based transistors, switches, and gates, to optimize space utilization or enhance the performance of user equipment. Processors can also be implemented as a combination of computing processing units. In this disclosure, terms such as “storage,” “data storage,” “database,” “database,” and substantially any other information storage component, used in connection with the operation and function of a component, are used to refer to a “memory component,” an entity embodied in “memory,” or a component that includes memory. It should be understood that the memory and / or memory components described herein can be volatile or non-volatile memory, or may include both. By way of example and not limitation, non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), flash memory, or non-volatile random access memory (RAM) (e.g., ferroelectric RAM (FeRAM)). Volatile memory may include, for example, RAM that can act as an external cache memory. By way of illustration and not limitation, RAM may be available in many forms, such as synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), Synchlink DRAM (SLDRAM), direct Rambus, etc. RAM (DRRAM), Direct Rambus Dynamic RAM (DRDRAM), and Rambus Dynamic RAM (RDRAM). Additionally, the memory components of the systems or computer-implemented methods disclosed herein are intended to include (but are not limited to) these and any other suitable types of memory.

[0160] The above description includes only examples of systems and computer-implemented methods. Of course, for the purposes of describing this disclosure, it is impossible to describe every conceivable combination of components or computer-implemented method; however, those skilled in the art will recognize that many further combinations and substitutions of this disclosure are possible. Furthermore, the terms “comprising,” “having,” “possessing,” etc., used in the detailed description, claims, appendices, and drawings are intended to be inclusive in a manner similar to the term “including,” since “including” is interpreted as a transitional word in the claims.

[0161] Various embodiments have been described for illustrative purposes, but are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein has been chosen to best explain the principles of the embodiments, their practical application, or technical improvements to technologies found in the market, or to enable those skilled in the art to understand the embodiments disclosed herein.

Claims

1. A system for facilitating backend quantum runtime, comprising: A processor that executes a computer-executable component stored in a computer-readable storage memory, the computer-executable component comprising: A back-end receiver component receives user input and a computer program from a client device, including one or more input parameters, wherein the computer program is configured to instruct quantum computing, and the one or more input parameters specify one or more software libraries required by the computer program for execution, and specify initial pre-defined parameters for use in the quantum computing; and A backend runtime manager component, which hosts the computer program by instantiating a runtime container on a backend classic computing device, wherein the runtime container: Based on the one or more input parameters, one or more software libraries required by the computer program are downloaded to the backend classical computing device. Instruct the backend quantum computing device to initialize the qubits to a defined quantum state for use in the quantum computing, and The computer program is orchestrated for classical execution on the back-end classical computing device using the one or more software libraries, and the quantum computation, instructed by the computer program, is performed on the qubits of the back-end quantum computing device using the initially proposed parameters.

2. The system according to claim 1, wherein, The backend quantum computing device executes the quantum computation instructed by the computer program in response to instructions from the runtime container.

3. The system according to claim 2, wherein, During execution by the backend classical computing device, the computer program utilizes quantum results generated by the backend quantum computing device to produce program results.

4. The system of claim 3, wherein the computer-executable component further comprises: A backend recording component that records the quantum result or the program result.

5. The system according to any one of claims 1 to 4, wherein the back-end classical computing device and the back-end quantum computing device are placed side by side, or wherein the back-end classical computing device and the back-end quantum computing device are coupled via a dedicated communication channel.

6. The system according to any one of claims 1 to 4, wherein the backend runtime manager component mediates communication between the client device and the computer program.

7. The system according to any one of claims 1 to 4, wherein the backend receiver component accesses another computer program provided by another client device, wherein the other computer program is configured to instruct another quantum computation, wherein the backend runtime manager component hosts the other computer program by instantiating another runtime container on the backend classical computing device, wherein the other runtime container orchestrates both the classical execution of the other computer program and the quantum execution of the other quantum computation instructed by the other computer program, and wherein the other runtime container operates in parallel with the runtime container.

8. A method for facilitating a computer implementation of a backend quantum runtime, comprising: A back-end device operatively coupled to a processor receives user input and a computer program from a client device, including one or more input parameters, wherein the computer program is configured to instruct quantum computing, and the one or more input parameters specify one or more software libraries required by the computer program for execution, and specify initial proposed parameters for use in the quantum computing; as well as The computer program is hosted by the backend device by instantiating a runtime container on the backend classic computing device, wherein the runtime container: Based on the one or more input parameters, one or more software libraries required by the computer program are downloaded to the backend classical computing device. Instruct the backend quantum computing device to initialize the qubits to a defined quantum state for use in the quantum computing, and The computer program is orchestrated for classical execution on the back-end classical computing device using the one or more software libraries, and the quantum computation, instructed by the computer program, is performed on the qubits of the back-end quantum computing device using the initially proposed parameters.

9. The computer-implemented method according to claim 8, further comprising: The quantum computing is performed on the backend quantum computing device by the backend device and in response to instructions from the runtime container.

10. The computer-implemented method according to claim 9, wherein, During execution by the backend classical computing device, the computer program utilizes quantum results generated by the backend quantum computing device to produce program results.

11. The computer-implemented method according to claim 10, further comprising: The backend device records the quantum result or the program result.

12. The computer-implemented method according to any one of claims 8 to 11, wherein the back-end classical computing device and the back-end quantum computing device are placed side by side, or wherein the back-end classical computing device and the back-end quantum computing device are coupled via a dedicated communication channel.

13. The computer-implemented method according to any one of claims 8 to 11, wherein the runtime container mediates communication between the client device and the computer program.

14. The computer-implemented method according to any one of claims 8 to 11, further comprising: The backend device accesses another computer program provided by another client device, wherein the other computer program is configured to instruct another quantum computation; as well as The backend device hosts the other computer program by instantiating another runtime container on the backend classical computing device, wherein the other runtime container orchestrates both the classical execution of the other computer program and the quantum execution of the other quantum computing instructed by the other computer program, and wherein the other runtime container operates in parallel with the runtime container.

15. A computer program product for facilitating back-end quantum runtime, the computer program product comprising a computer-readable storage medium having program instructions implemented therewith, the program instructions being executable by a back-end processor to cause the back-end processor to: The backend processor receives user input and a computer program from a client device, including one or more input parameters, wherein the computer program is configured to instruct quantum computing, and the one or more input parameters specify one or more software libraries required by the computer program for execution, and specify initial pre-defined parameters for use in the quantum computing; and The computer program is hosted by the backend processor by instantiating a runtime container on a backend classic computing device, wherein the runtime container: Based on the one or more input parameters, one or more software libraries required by the computer program are downloaded to the backend classical computing device. Instruct the backend quantum computing device to initialize the qubits to a defined quantum state for use in the quantum computing, and The computer program is orchestrated for classical execution on the back-end classical computing device using the one or more software libraries, and the quantum computation, instructed by the computer program, is performed on the qubits of the back-end quantum computing device using the initially proposed parameters.

16. The computer program product according to claim 15, The program instructions thereon can be further executed to cause the back-end processor to: The quantum computing is performed on the backend quantum computing device by the backend processor and in response to instructions from the runtime container.

17. The computer program product according to claim 16, wherein, During execution by the backend classical computing device, the computer program utilizes quantum results generated by the backend quantum computing device to produce program results.

18. The computer program product of claim 17, wherein the program instructions are further executable to cause the back-end processor to: The back-end processor records the quantum result or the program result.

Images