Program compilation for large-scale quantum computers

Practical realizations of quantum computers are poised to deliver outstanding computational capabilities far beyond the reach of any classical supercomputer. While classical systems are reliably implemented using CMOS technology, the fabrication of quantum hardware has not yet reached a commercially viable level of maturity. Nowadays, many different technologies are being developed as competing candidates to build the first error-corrected quantum computer. Among the software resources required to operate such a system, quantum compilers translate a high-level description of a quantum algorithm into low-level, technology-dependent quantum instructions.

Many quantum algorithms, including Shor's and Grover's algorithms, require to compute some classical logic functions on the quantum computer. The first part of this thesis deals with the problem of compiling quantum circuits that perform such classical Boolean functions, called oracles, into a fault-tolerant set of instructions.
Oracle circuits often demand many resources in terms of the number of qubits and gates. The focus is on compiling quantum circuits starting from multi-level logic networks representing large Boolean functions while minimizing the resource footprint of the obtained quantum circuits. At the same time, the trade-off between memory resources and the number of operations typical of such a compilation process is explored. As part of the effort in reducing the resources required to perform a given quantum program, I also present some quantum circuit optimization techniques.

The researched algorithms leverage data structures and techniques borrowed and adapted from classical logic synthesis, e.g., SAT solvers, LUT mapping, and multi-level logic networks. I implemented all the compilation algorithms presented in this thesis as part of open-source projects. In particular, I develop and maintain caterpillar---a C++ header-only library dedicated to the quantum compilation of oracles and quantum memory management.

The second part of this thesis describes how to equip quantum programming language compilers with automatic accuracy management. Despite the availability of many of such languages, resource estimation of quantum algorithms does not yet support taking approximation errors into account. This general methodology is applicable to any programming language and I demonstrate its integration into the Q# compiler. The technique consists of providing language support to ease the accuracy-aware programming task. The user can define accuracy parameters that will be automatically optimized according to a constraint and a cost function directly generated from the source code. In the presented practical evaluations, the constraint function is the overall allowed accuracy, while the cost function is application-dependent and related to the number of gates. During the optimization process, such functions are evaluated hundreds of times. For this reason, we extract them as (near-)symbolic expressions, whose evaluation time does not depend on the quantum algorithm size.

The algorithms and the methodologies presented in this thesis are part of a widespread effort of the research community to build a complete and efficient software stack to program and control the first practical universal quantum computer.

Compiling scala for the Java virtual machine

Michel Schinz

Scala is a new programming language developed at EPFL and incorporating the most important concepts of object-oriented and functional languages. It aims at integrating well with the Java and .NET platforms: their respective libraries are accessible without glue code, and the compiler can produce programs for both virtual machines. This thesis focuses on the compilation of two important concepts of Scala : mixin inheritance and run time types. The compilation techniques are presented in the context of the Java virtual machine, but could be adapted easily to other similar environments. Mixin inheritance is a relatively recent form of inheritance, offering new capabilities compared to single inheritance, without the complexity of multiple inheritance. We propose two implementation techniques for mixin inheritance: code copying and delegation. The implementation used in the Scala compiler is then presented and justified. Run time types make it possible for a program to examine the type of its values during execution. This possibility is interesting in itself, offering new capabilities to the programmer. Furthermore, run time types are also required to implement other high level concepts, like pattern matching, type-safe serialisation and reflection. We propose an implementation technique based on the representation of types as values, and show how to use the run time types of the underlying virtual machine to implement those of Scala. The techniques presented in this thesis have been implemented in our Scala compiler, scalac. This enabled us to evaluate these techniques, in particular their impact on the performances of programs. This evaluation was performed on several real, non-trivial programs.

EPFL2005

On the Efficiency of Semiclassical and Classical Approximations of Quantum Fidelity in Many-Dimensional Systems

Cesare Mollica

This thesis is focused on classical and semiclassical approximations of a specific quantum time correlation function, the “quantum fidelity.” Namely, we rigorously study the efficiency of a continuous class of algorithms for the evaluation of its classical limit and both the cost and the error of a particular semiclassical approximation of it. In the physics domain, quantum fidelity can be used to study the cross section of inelastic neutron scattering and phenomena like decoherence and irreversibility in NMR experiments. In chemical physics, quantum fidelity can be employed to compute the spectrum of a quantum state, to evaluate the accuracy of quantum dynamics on an approximate potential energy surface, and to verify the importance of nonadiabatic electronic transitions in molecules. Unfortunately, as for any numerical simulation of a quantum dynamical object, many-dimensional calculations of quantum fidelity are extremely expensive computationally. Classical methods, not including any quantum effect, are generally believed to be efficient approximations for the numerical evaluation of large systems’ properties when quantum effects are not important. We prove that, previous to this research, the computational costs of available algorithms for the simulation of classical fidelity increased exponentially with the number of degrees of freedom and we single out, within a continuous family of algorithms, the only one for which the number of trajectories needed for convergence is independent of the system’s dimensionality. Recently a semiclassical method, called “dephasing representation” (DR), has been proposed to approximate quantum fidelity accurately and efficiently. Although semiclassical methods, approximately including all types of quantum effects, are generally more accurate but much less efficient than classical methods, we prove that for the semiclassical DR there exists at least one algorithm for which the number of trajectories needed for convergence is independent of dimensionality and also that this semiclassical algorithm is even faster than the most efficient classical fidelity algorithm previously singled out. Encouraged by the surprising efficiency of the specific semiclassical method, we investigate the error of the DR compared to the quantum benchmark.

EPFL2012

Two approaches to portable macros

Eugene Burmako, Fengyun Liu

For any programming language that supports macros and has multiple implementations (each with different AST definitions), there is a common problem: how to make macros that operate on ASTs portable among different compiler implementations? Implementing portable macros is especially important for statically typed languages like Scala, as IDE vendors usually have different implementations of the language in order to support rich IDE features. Unportable macros compromise IDE features and degrade programming experience. We describe two approaches to the portability problem based on two different views on macros: (1) the tree-based approach, which views macros as operations on abstract syntax trees, solves the problem by defining standard abstract syntax trees; (2) the syntax-based approach, which views macros as operations on abstract syntax, solves the problem by defining standard abstract syntax. We show that the latter has significant practical advantages, especially in supporting semantic macros that use type information of ASTs to transform user code. Based on the idea, we implemented a new macro system, Gestalt, for the experimental Scala compiler, Dotty. The new implementation solves several long-standing problems of the current Scala macro system and demonstrates advantages over alternative approaches. Our solution has been adopted in the official new Scala macro system.

2017

On the Efficiency of Semiclassical and Classical Approximations of Quantum Fidelity in Many-Dimensional Systems

Cesare Mollica

EPFL2012