Automated accuracy management of quantum programs via symbol resource estimation

Abstract

Embodiments of the disclosed technology relate to transforming high-level quantum computer programs into one or more symbolic expressions. Because the transformations result in symbolic expressions in the compiled code, one can extract these symbolic expressions to obtain a symbolic resource estimate for the quantum program. In cases where these transformations do not yield a closed-form solution, they can still be evaluated orders of magnitude faster than possibly using other resource estimation tools. Access to such symbolic or near-symbolic expressions not only greatly improves the performance of accuracy management and resource estimation, but also can better inform quantum software developers of potential bottlenecks in the quantum program. In turn, the underlying quantum computer program can be improved as appropriate.

Description

[0001] Cross-reference to related applications

[0002] This application claims priority to U.S. Provisional Application No. 62 / 916623, filed October 17, 2019, and U.S. Patent Application No. 16 / 843733, filed April 8, 2020, the entire contents of which are incorporated herein by reference. Technical Field

[0003] This application relates to quantum computing devices. Specifically, this application relates to techniques for generating low-level instructions specific to quantum computers using symbol resource estimation as part of the compilation process. Summary of the Invention

[0004] This article discloses example implementations for generating low-level instructions specific to quantum computers using symbolic resource estimation.

[0005] When translating a quantum program into target-specific low-level instructions, some high-level subroutines must be rewritten in a manner that introduces some approximation error (they must be decomposed). While these errors can be reduced, doing so generally increases the required quantum resources (e.g., the number of operations and / or the number of qubits). Programmers typically know the overall fault tolerance of the program in question. However, given this information, it is not straightforward to infer the optimal choice of accuracy parameters for all the decompositions that occur during the compilation of a quantum computing device.

[0006] As a remedy, the disclosed techniques involve various improvements to automate the process and add this functionality to quantum program compilers. In this disclosure, the resulting optimization problem can be solved using a simulated annealing procedure; furthermore, this disclosure explains how this can be achieved in a manner several orders of magnitude faster. For example, in a particular embodiment, the process involves transforming the code expressing the optimization problem into a symbolic expression. Because this transformation results in a symbolic expression in the compiled code, symbolic resource estimates for the quantum program in question can be extracted. Even when these transformations do not produce a closed-form solution, they can still be evaluated many orders of magnitude faster than could be achieved using other resource estimation tools. Access to such symbolic or approximate symbolic expressions not only significantly improves the performance of accuracy management and resource estimation but also better informs quantum software developers and theorists of potential bottlenecks in quantum programs. In turn, the disclosed techniques provide new avenues and techniques for improving underlying quantum programs.

[0007] Previous resource estimators used a simulator-like approach that counted operations. This approach required executing all loops and other control flow statements in the code. In contrast, embodiments of the disclosed technique identify these loops in the code, eliminate them where possible, and symbolically simplify the mathematical expressions for the total operation count and / or total error introduced by the quantum program. This allows developers significant progress because the method produces a concise expression for, for example, the total gate count, as a function of the input parameters (e.g., all input parameters), which can then be specified to obtain specific numbers. Simulator-like methods would have to rerun the entire estimation process for each new parameter selection.

[0008] Furthermore, embodiments of the disclosed loop elimination optimization method accelerate the evaluation of the resulting expressions by several orders of magnitude. This is crucial when using a resource estimator as a subroutine to find the optimal accuracy parameters for a quantum program, as this requires numerous evaluations of different parameters.

[0009] Currently, there is no technology in the field of quantum computing that supports symbolic (or approximate symbolic) resource estimation and automated accuracy management. Many domain experts and quantum program developers are therefore unable to perform highly efficient resource estimation; instead, current methods require a considerable amount of time to understand and compute error propagation in quantum programs.

[0010] The disclosed embodiments of the technology provide a solution that enables quantum program developers to obtain detailed and optimized resource estimations. Furthermore, support for symbolic resource estimation is attractive to quantum program developers and researchers working on quantum information theory and algorithms. Using the embodiments of the disclosed technology, upper limits for gate counts can be automatically generated without requiring lengthy manual calculations.

[0011] The foregoing and other objects, features and advantages of the disclosed technology will become more apparent from the following detailed description with reference to the accompanying drawings. Attached Figure Description

[0012] Figure 1 A generalized example of a suitable classical computing environment in which aspects of the described embodiments can be implemented is shown.

[0013] Figure 2 Examples of possible network topologies (e.g., client-server networks) for implementing systems based on the disclosed techniques are shown.

[0014] Figure 3 Another example of a possible network topology (e.g., a distributed computing environment) for implementing a system based on the disclosed technology is shown.

[0015] Figure 4 An exemplary system for implementing the disclosed techniques is shown, wherein the system includes one or more classical computers that communicate with a quantum computing device.

[0016] Figures 5-6 This is a flowchart of an example embodiment for performing the disclosed technology. Detailed Implementation

[0017] I. Overall Considerations

[0018] The disclosed methods, apparatuses, and systems should not be construed as limiting in any way. Rather, this disclosure is directed to all novel and non-obvious features and aspects of the various disclosed embodiments, individually or in various combinations and sub-combinations with each other. Furthermore, any feature or aspect of the disclosed embodiments may be used in various combinations and sub-combinations with each other. For example, one or more method actions from one embodiment may be used with one or more method actions from another embodiment, and vice versa. The disclosed methods, apparatuses, and systems are not limited to any particular aspect or feature or combination thereof, and the disclosed embodiments do not claim to have any one or more particular advantages or problems solved.

[0019] Various alternatives to the examples described herein are possible. Various aspects of the disclosed techniques can be used in combination or individually. Different embodiments utilize one or more of the described innovations. Some of the innovations described herein address one or more problems mentioned in the background art. Typically, a given technique / tool ​​cannot solve all such problems.

[0020] The singular forms “a,” “an,” and “the” used in this application and claims include the plural forms unless the context clearly specifies otherwise. Furthermore, the term “comprising” means “including.” Additionally, as used herein, the term “and / or” means any one or any combination of the terms.

[0021] II. Detailed embodiments of the disclosed technology

[0022] This article discloses example embodiments of a technique for generating low-level instructions specific to quantum computers using symbolic resource estimation.

[0023] When translating a quantum program into target-specific low-level instructions, some high-level subroutines must be rewritten from the low-level subroutines in a way that introduces some approximation errors (they must be decomposed). While these errors can be reduced, doing so generally increases the required quantum resources (number of operations and number of qubits). Quantum program programmers typically know the overall fault tolerance of the program in question. However, given this information, inferring the optimal choice of accuracy parameters for all the decompositions that occur during compilation is not straightforward.

[0024] As a remedy, the disclosed technology describes an automated process that can be used in quantum program compilers.

[0025] In another job (see The paper "Managing Approximation Errors in Quantum Programs" by [Authors' Name] (available at https: / / arxiv.org / pdf / 1807.02336) demonstrates how to solve the resulting optimization problem using simulated annealing procedures. However, this work does not delve into the details of how to implement the problem to be solved. In this disclosure, it will be shown how to achieve this in a way that is several orders of magnitude faster. This can be achieved by transforming the code expressing the optimization problem. Because the disclosed transformations typically result in fully symbolic expressions in the compiled code, these expressions can be extracted to obtain symbolic resource estimates for the quantum program in question. Even when these transformations do not produce a closed-form solution, they can still be evaluated many orders of magnitude faster than other resource estimation tools might be used. Access to such symbolic or approximate symbolic expressions not only greatly improves the performance of accuracy management and resource estimation but also better informs theorists of potential bottlenecks in the quantum program. This, in turn, allows for improvements to the underlying quantum algorithm(s).

[0026] This disclosure describes exemplary methods for specifying approximate decompositions in code. In modern quantum programming languages, the resulting accuracy parameter is either a constant (and therefore incorrect in general) or must be passed along with any other parameter. While the first approach ultimately fails to produce correct quantum circuits, the second approach is impractical from a programmer's perspective.

[0027] Consider a quantum operation that calls several imperfect subroutines. Each such operation needs to know all the accuracy parameters introduced by itself, its subroutines, and all the subroutines executed by any of its subroutines. For example,

[0028] qfunction f(eps1, eps2,…, epsN, qureg):

[0029] g(eps1, qureg[0])

[0030] h(eps2, eps3, qureg[1-3])

[0031] …

[0032] z(epsN, qureg)

[0033] h(eps2, eps3, qureg[1-3]) can pass eps3 to only one of its subroutines.

[0034] This is clearly not a scalable way to handle approximation errors. Using the disclosed techniques, each subroutine knows exactly the accuracy parameters of the code that directly affect it. Furthermore, these parameters can be defined anywhere in the code.

[0035] Therefore, the above example will be denoted as:

[0036] qfunction f(qureg):

[0037] Eps my_eps;

[0038] g(qureg[0])

[0039] h(qureg[1-3])

[0040] …

[0041] z(qureg)

[0042] The implementation of f(qureg) can use my_eps in its implementation as if it were a real number (e.g., 0.001). Clearly, this is scalable and is supported by embodiments of the disclosed technology as input. Once the code is written in this form, it can be used within the disclosed framework. Specifically, the disclosed framework consists of... Figure 4 and Figure 5 Flowcharts 400 and 500 are shown in the diagram. In the illustrated framework, one or more (e.g., all) quantum routines are transformed in the code. In a particular example implementation, this transformation adds two additional versions to one or more subroutines (e.g., each subroutine). This essentially duplicates the program (e.g., the entire program) twice. One copy determines the number of non-free operations, and the second copy tracks the overall error introduced by the approximation decomposition. Furthermore, in some embodiments, one or more (e.g., all) calls to "free" operations are removed. In some example implementations, the programmer can specify which operations are expensive / free.

[0043] Three copies can be fed into the optimizer; these three copies are functions of accuracy parameters (e.g., all accuracy parameters) that appear in the code. By repeatedly calling two additional copies (to calculate the operation count and total error), the optimizer can attempt to reduce the operation count while ensuring the total error is less than a user-specified error threshold. While simple to implement, this approach suffers from the problems of previous resource estimation tools: all loops in the quantum program are executed thousands of times during the optimization process.

[0044] As a remedy, embodiments of the disclosed technology introduce specific loop optimizations that allow the elimination of one or more of these loops. Specifically, and in some embodiments, this form of loop is transformed:

[0045]

[0046] Doing this iteratively typically allows eliminating all loops in both copies of the program (for operation counting and total error). In the case of a program with only one loop, notice that n additions are replaced by one addition and one multiplication. Considering that these two operations can be executed as a single fused multiply-accumulate instruction on modern processor architectures, one can expect a speedup of approximately n times, resulting in a substantial improvement. Typical quantum programs contain many nested loops. Therefore, speedups of many orders of magnitude are readily achievable.

[0047] Once all possible loop optimizations have been performed, including intermediate reassociations and loop simplification / normalization, the procedure for calculating the gate count or overall error becomes much simpler. In many practical examples, the program contains only one loop, typically in the following form.

[0048] for i = 1: n

[0049] eps+=f(i)*delta_eps;

[0050] Such loops generally cannot be further optimized. However, the program is approximately symbolic, meaning that symbolic expressions exist for f(i) and delta_eps. Therefore, example embodiments of the disclosed technique can traverse the low-level representation of the program from the final return statement (returning the gate count or total error) that returns to the program's input (which may be unknown or a compile-time constant). Loops like the one above use well-known formulas (e.g., geometric series) to produce summation expressions that can be symbolically simplified in many cases. After simplification, the disclosed framework can output two symbolic expressions as functions of all algorithmic and decomposition parameters (e.g., problem size and decomposition accuracy parameters), which can be used to efficiently evaluate the gate count and total error.

[0051] Furthermore, some special cases of branching can be optimized using the disclosed framework. For example, embodiments of the disclosed technique identify branching expressions in the form of a low-level representation for calculating the minimum of two actual arguments. This allows one to use Sum_i_Min(f(i),g(i))<=Min(Sum_i f(i),Sum_i g(i)) to ultimately output two upper bounds for the gate count and the total error, respectively. Typically, this transformation allows for further simplification of the two sums on the right-hand side.

[0052] III. Example Computing Environment

[0053] Figure 1 A general example of a suitable classical computing environment 100 in which the aspects of the described embodiments can be implemented is shown. The computing environment 100 is not intended to impose any limitation on the scope or functionality of the disclosed techniques, as the techniques and tools described herein can be implemented in a variety of general-purpose or specialized environments with computing hardware.

[0054] refer to Figure 1 The computing environment 100 includes at least one processing device 110 and a memory 120. Figure 1 In this context, this most basic configuration 130 is included within the dashed lines. Processing device 110 (e.g., CPU or microprocessor) executes computer-executable instructions. In a multiprocessing system, multiple processing devices execute computer-executable instructions to increase processing power. Memory 120 may be volatile memory (e.g., registers, cache, RAM, DRAM, SRAM), non-volatile memory (e.g., ROM, EEPROM, flash memory), or some combination of both. Memory 120 stores software 180, which implements tools for performing any of the techniques disclosed herein to develop quantum computer programs and / or operate a quantum computer, as described herein. Memory 120 may also store software 180 for synthesizing, generating, or compiling quantum circuits to perform any of the techniques disclosed herein.

[0055] The computing environment may have additional features. For example, computing environment 100 includes storage device 140, one or more input devices 150, one or more output devices 160, and one or more communication connections 170. Interconnection mechanisms (not shown), such as buses, controllers, or networks, interconnect the components of computing environment 100. Typically, operating system software (not shown) provides an operating environment for other software executing in computing environment 100 and coordinates the activities of the components of computing environment 100.

[0056] Storage device 140 may be removable or non-removable and includes one or more disks (e.g., hard disk drives), solid-state drives (e.g., flash drives), magnetic tape or cassette tape, CD-ROMs, DVDs, or any other tangible non-volatile storage medium that can be used to store information and can be accessed within computing environment 100. Storage device 140 may also store instructions for software 180 used to implement any of the techniques disclosed in the art. Storage device 140 may also store instructions for software 180 used to generate and / or synthesize any of the techniques, systems, or quantum circuits described in the art.

[0057] Multiple input devices 150 may be touch input devices (such as keyboards, touch screens, mice, pens, trackballs), voice input devices, scanning devices, or other devices that provide input to computing environment 100. Multiple output devices 160 may be display devices (e.g., computer monitors, laptop monitors, smartphone displays, flat panel displays, netbook displays, or touch screens), printers, speakers, or other devices that provide output from computing environment 100.

[0058] Multiple communication connections 170 enable communication with another computing entity via a communication medium. The communication medium transmits information, such as computer-executable instructions, or other data in modulated data signals. A modulated data signal is a signal whose characteristics are set or altered in a manner that encodes information within it. By way of example and not limitation, communication media include wired or wireless technologies implemented using electrical, optical, RF, infrared, acoustic, or other carriers.

[0059] As described above, any techniques for performing the disclosed techniques, and various methods and techniques for controlling a quantum computing device to perform the circuit designs or compilation / synthesis disclosed herein, can be described within the overall context of computer-readable instructions stored on one or more computer-readable media. A computer-readable medium is any available medium (e.g., memory or storage device) that can be accessed within or by a computing environment. Computer-readable media include tangible computer-readable memories or storage devices, such as memory 120 and / or storage device 140, and do not include the propagation carrier or signal itself (tangible computer-readable memories or storage devices do not include the propagation carrier or signal itself).

[0060] Various embodiments of the methods disclosed herein can also be described within the overall context of computer-executable instructions (such as instructions included in a program module) that are executed by a processor in a computing environment. Typically, program modules include routines, programs, libraries, objects, classes, components, data structures, etc., which perform specific tasks or implement specific abstract data types. In various embodiments, the functionality of program modules can be combined or divided among program modules as needed. The computer-executable instructions for program modules can execute in a local or distributed computing environment.

[0061] exist Figure 2 The document describes an example of a possible network topology 200 (e.g., a client-server network) for implementing a system according to the disclosed technology. The networked computing device 220 may be, for example, a computer running a browser or other software connected to network 212. The computing device 220 may have, for example, […]. Figure 1 The computer architecture is shown and described above. Computing device 220 is not limited to a traditional personal computer, but may include other computing hardware (e.g., smartphones, laptops, tablets or other mobile computing devices, servers, network devices, dedicated devices, etc.) configured to connect to and communicate with network 212. Furthermore, computing device 220 may include FPGAs or other programmable logic devices. In the illustrated embodiment, computing device 220 is configured to communicate with computing device 230 (e.g., a remote server, such as a server in a cloud computing environment) via network 212. In the illustrated embodiment, computing device 220 is configured to transmit input data to computing device 230, and computing device 230 is configured to implement techniques for controlling a quantum computing device to perform any of the techniques of the disclosed embodiments, and / or circuit generation / compilation / synthesis techniques for generating quantum circuits to perform any of the techniques disclosed herein. Computing device 230 may output results to computing device 220. Any data received from computing device 230 may be stored or displayed on computing device 220 (e.g., displayed as data on a graphical user interface at computing device 220 or on a webpage). In the illustrated embodiment, the illustrated network 212 may be implemented as a local area network (“LAN”) using wired networking (e.g., Ethernet IEEE standard 802.3 or other suitable standards) or wireless networking (e.g., one of IEEE standards 802.11a, 802.11b, 802.11g, or 802.11n or other suitable standards). Alternatively, at least a portion of network 212 may be the Internet or a similar public network and operate using a suitable protocol (e.g., HTTP protocol).

[0062] exist Figure 3Another example of a possible network topology 300 (e.g., a distributed computing environment) for implementing a system according to the disclosed technology is described. The networked computing device 320 can be, for example, a computer running a browser or other software connected to the network 312. The computing device 320 can have, for example, […]. Figure 1 The computer architecture is shown and described above. In the illustrated embodiment, computing device 320 is configured to communicate via network 312 with multiple computing devices 330, 331, 332 (e.g., remote servers or other distributed computing devices, such as one or more servers in a cloud computing environment). In the illustrated embodiment, each of the computing devices 330, 331, 332 in computing environment 300 is used to perform at least a portion of the disclosed techniques, and / or to control quantum computing devices to perform at least a portion of the techniques of any embodiment disclosed herein, and / or to generate quantum circuits to perform circuit generation / compilation / synthesis techniques of any techniques disclosed herein. In other words, computing devices 330, 331, 332 form a distributed computing environment in which technical aspects of performing any techniques disclosed herein and / or quantum circuit generation / compilation / synthesis processes are shared among multiple computing devices. Computing device 320 is configured to transmit input data to computing devices 330, 331, and 332. Computing devices 330, 331, and 332 are configured to implement processes in a distributed manner, including the execution of any method in the disclosed methods or the creation of any circuitry in the disclosed circuitry, and to provide results to computing device 320. Any data received from computing devices 330, 331, and 332 may be stored or displayed on computing device 320 (e.g., displayed as data on a graphical user interface at computing device 320 or on a webpage). The network 312 shown may be as described above. Figure 2 Any network in the network under discussion.

[0063] refer to Figure 4 An exemplary system for implementing the disclosed techniques includes a computing environment 400. In the computing environment 400, a compiled quantum computer circuit description (including quantum circuits for performing any of the disclosed techniques, as disclosed herein) can be used to program (or configure) one or more quantum processing units such that the quantum processing units implement the circuits described by the quantum computer circuit description.

[0064] Environment 400 includes one or more quantum processing units 402 and one or more readout devices 408. The quantum processing units execute quantum circuits pre-compiled and described by a quantum computer circuit description. The quantum processing units can be one or more, but not limited to, the following: (a) a superconducting quantum computer; (b) an ion trap quantum computer; (c) a fault-tolerant architecture for quantum computing; and / or (d) a topological quantum architecture (e.g., a topological quantum computing device using Majorana zero modes). The pre-compiled quantum circuits (including any circuits disclosed in the circuitry) can be sent to (or applied to) the quantum processing units via control line 406 under the control of a quantum processor controller 420. The quantum processor controller (QP controller) 420 can be coupled to a classical processor 410 (e.g., having the features described above). Figure 1 The described architecture is combined to operate in order to achieve a desired quantum computing process. In the example shown, the QP controller 420 also implements the desired quantum computing process via one or more QP sub-controllers 404, which are specifically adapted to control corresponding quantum processors in the quantum processor(s) 402. For example, in one example, the quantum controller 420 facilitates the implementation of a compiled quantum circuit by sending instructions to one or more memories (e.g., cryogenic memories), which then pass the instructions to the cryogenic control units (e.g., the QP sub-controllers 404), which transmit, for example, a sequence of pulses representing gates to the quantum processing units 402 for implementation. In other examples, the QP controller 420 and the QP sub-controllers 404 operate to provide appropriate magnetic fields, encoded operations, or other such control signals to the quantum processors to implement the operations described in the compiled quantum computer circuit. Multiple quantum controllers can further interact with the readout device 408 to help control and achieve the desired quantum computing process (e.g., by reading out or measuring data results from the quantum processing unit as soon as they become available).

[0065] refer to Figure 4 Compilation is the process of translating a high-level description of a quantum algorithm into a quantum computer circuit description that includes sequences of quantum operations or gate sequences. This quantum computer circuit description may include circuits disclosed herein (e.g., circuits configured to execute one or more programs disclosed herein, or circuits generated by any of the techniques disclosed). Compilation may be performed by compiler 422 using a classical processor 410 of environment 400 (e.g., such as...). Figure 4 (As shown) to execute, the processor 410 loads a high-level description from a memory or storage device 412 and stores the resulting quantum computer circuit description in the memory or storage device 412.

[0066] In other embodiments, compilation and / or verification may be performed by a remote computer 460 (e.g., having the above-mentioned...). Figure 1 The computational environment (computer) is executed remotely. The remote computer 460 stores the generated quantum computer circuit description in one or more memories or storage devices 462 and transmits the quantum computer circuit description to the computational environment 400 for implementation in the quantum processing unit(s) 402. Furthermore, the remote computer 400 can store a high-level description in the memory or storage device 462 and transmit that high-level description to the computational environment 400 for compilation and use with the quantum processor(s). In any of these scenarios, the result of the computation performed by the quantum processor(s) can be transmitted to the remote computer after and / or during the computation process. Additionally, the remote computer can communicate with the quantum P controller(s) 420, allowing the quantum computing process (including any compilation, verification, and QP control programs) to be remotely controlled by the remote computer 460. Typically, the remote computer 460 communicates with the quantum P controller(s) 420, compiler / synthesizer 422, and / or verification tool 423 via communication connection 450.

[0067] In a particular embodiment, environment 400 may be a cloud computing environment that provides the quantum processing resources of environment 400 to one or more remote computers (such as remote computer 460) via a suitable network (which may include the Internet).

[0068] VI. Conclusion

[0069] The disclosed methods, apparatuses, and systems should not be construed as limiting in any way. Rather, this disclosure is directed toward all novel and non-obvious features and aspects of the various disclosed embodiments, individually and in various combinations and sub-combinations of each other. The disclosed methods, apparatuses, and systems are not limited to any particular aspect or feature or combination thereof, nor are the disclosed embodiments required to have any one or more particular advantages or problems solved.

[0070] Given the many possible embodiments in which the principles of the disclosed technology can be applied, it should be recognized that the illustrated embodiments are examples of the disclosed technology and should not be considered as a limitation on the scope of the disclosed technology.

Claims

1. A method comprising: Compile the high-level description of a quantum computer program into a low-level description that can be implemented by a quantum computer. The compilation includes traversing a high-level description of the quantum computer program; and generating one or more symbolic expressions based on the traversal to produce the high-level description of the quantum computer program. The generation includes using the definition of accuracy parameters within the function body of the high-level description of the quantum computer program as a built-in language construct, wherein the accuracy parameters allow the compiler to specify approximation errors introduced by a particular quantum computer implementation associated with the low-level description.

2. The method of claim 1, further comprising an automatic rewriting step, wherein the automatic rewriting step transforms the high-level description of the quantum computer program to count gates.

3. The method according to claim 1, further comprising an automatic rewriting step, wherein the automatic rewriting step transforms the high-level description of the quantum computer program to calculate the overall error bound.

4. The method of claim 1, further comprising an automatic rewriting step, wherein the automatic rewriting step transforms the high-level description of the quantum computer program to count gates, and transforms the high-level description of the quantum computer program to calculate an overall error bound.

5. The method of claim 1, further comprising an automatic rewriting step, the automatic rewriting step comprising invoking an optimizer, the optimizer then forwarding optimization parameters for execution.

6. The method of claim 5, wherein the optimizer implements the simulated annealing step.

7. The method according to claim 1, further comprising: Perform one or more rewrite operations, which transform the high-level description of the quantum computer program to count gates or to calculate the overall error bound. An optimization process is performed on the loop caused by the one or more rewrite actions, wherein the optimization process includes ignoring floating-point errors.

8. The method according to claim 1, further comprising: Perform one or more rewrite operations, which transform the high-level description of the quantum computer program to count gates or to calculate the overall error bound. An optimization process is performed on the loops caused by the one or more rewrite actions, wherein the optimization process includes converting the sum of the one or more loops into a product.

9. The method of claim 1, further comprising performing one or more rewriting operations, said one or more rewriting operations transforming the high-level description of the quantum computer program to count gates or transforming the high-level description of the quantum computer program to calculate an overall error bound. The execution of the one or more rewrite actions is performed iteratively, and the one or more rewrite actions transform the high-level description of the quantum computer program to count gates or transform the high-level description of the quantum computer program to calculate the overall error bound.

10. The method of claim 7, wherein the one or more rewrite actions are interleaved with one or more of a reassociation iteration or a loop simplification iteration.

11. A system comprising: processor; as well as A computer-readable medium storing processor-executable instructions, which, when executed by the processor, cause the processor to implement a compiler for translating high-level quantum computer programs into low-level quantum computer programs. The translations mentioned therein include: Traverse the advanced quantum computer program; as well as Based on the traversal of the advanced quantum computer program, one or more symbolic expressions of the advanced quantum computer program are generated; and The generation includes using the definition of accuracy parameters within the function body of the advanced quantum computer program as a built-in language construct, wherein the accuracy parameters allow the compiler to specify the approximation error and gate count associated with each of the one or more symbolic expressions.

12. The system of claim 11, wherein the traversal of the advanced quantum computer program is from the end of the advanced quantum computer program to the beginning of the advanced quantum computer program.

13. The system of claim 11, wherein the ergodicity of the advanced quantum computer program takes into account constants and the inputs of the advanced quantum computer program.

14. The system of claim 11, wherein the traversal supports the summation of the loop, and a symbolic expression for the summation of the loop is generated.

15. A method comprising: Input advanced quantum computer program; as well as In the case of a single call to the compiler for the advanced quantum computer program, one or more accuracy parameters of the advanced quantum computer program are improved, wherein compilation includes traversing the advanced quantum computer program and generating one or more symbolic expressions of the advanced quantum computer program, wherein the generation includes using the definition of the accuracy parameters within the function body of the advanced quantum computer program as a built-in language construct, wherein the accuracy parameters allow the compiler to specify approximation errors introduced by a specific quantum computer implementation associated with the low-level description.

16. The method of claim 15, wherein the improvement comprises generating symbolic expressions for one or more aspects of the advanced quantum computer program.

17. The method of claim 16, wherein the improvement comprises transforming at least a portion of a high-level description of the quantum computer program to count gates.

18. The method of claim 16, wherein the improvement comprises transforming at least a portion of the high-level description of the quantum computer program to calculate the overall error bound.

19. The method of claim 15, wherein the improvement includes performing a simulated annealing step.

Images