0.5 Petabyte Simulation of a 45-Qubit Quantum Circuit

Near-term quantum computers will soon reach sizes that are challenging to directly simulate, even when employing the most powerful supercomputers. Yet, the ability to simulate these early devices using classical computers is crucial for calibration, validation, and benchmarking. In order to make use of the full potential of systems featuring multi- and many-core processors, we use automatic code generation and optimization of compute kernels, which also enables performance portability. We apply a scheduling algorithm to quantum supremacy circuits in order to reduce the required communication and simulate a 45-qubit circuit on the Cori II supercomputer using 8,192 nodes and 0.5 petabytes of memory. To our knowledge, this constitutes the largest quantum circuit simulation to this date. Our highly-tuned kernels in combination with the reduced communication requirements allow an improvement in time-to-solution over state-of-the-art simulations by more than an order of magnitude at every scale

Programming Quantum Computers Using Design Automation

Recent developments in quantum hardware indicate that systems featuring more than 50 physical qubits are within reach. At this scale, classical simulation will no longer be feasible and there is a possibility that such quantum devices may outperform even classical supercomputers at certain tasks. With the rapid growth of qubit numbers and coherence times comes the increasingly difficult challenge of quantum program compilation. This entails the translation of a high-level description of a quantum algorithm to hardware-specific low-level operations which can be carried out by the quantum device. Some parts of the calculation may still be performed manually due to the lack of efficient methods. This, in turn, may lead to a design gap, which will prevent the programming of a quantum computer. In this paper, we discuss the challenges in fully-automatic quantum compilation. We motivate directions for future research to tackle these challenges. Yet, with the algorithms and approaches that exist today, we demonstrate how to automatically perform the quantum programming flow from algorithm to a physical quantum computer for a simple algorithmic benchmark, namely the hidden shift problem. We present and use two tool flows which invoke RevKit. One which is based on ProjectQ and which targets the IBM Quantum Experience or a local simulator, and one which is based on Microsoft's quantum programming language Q$\#$.Comment: 10 pages, 10 figures. To appear in: Proceedings of Design, Automation and Test in Europe (DATE 2018

Computing all monomials of degree n−1n-1 using 2n−32n-3 AND gates

We consider the vector-valued Boolean function $f:\{0,1\}^n\rightarrow \{0,1\}^n$ that outputs all $n$ monomials of degree $n-1$, i.e., $f_i(x)=\bigwedge_{j\neq i}x_j$, for $n\geq 3$. Boyar and Find have shown that the multiplicative complexity of this function is between $2n-3$ and $3n-6$. Determining its exact value has been an open problem that we address in this paper. We present an AND-optimal implementation of $f$ over the gate set $\{\text{AND},\text{XOR},\text{NOT}\}$, thus establishing that the multiplicative complexity of $f$ is exactly $2n-3$

Space-time optimized table lookup

We describe a space-time optimized circuit for the table lookup subroutine from lattice-surgery surface code primitives respecting 2D grid connectivity. Table lookup circuits are ubiquitous in quantum computing, allowing the presented circuit to be used for applications ranging from cryptography to quantum chemistry. Surface code is the leading approach to scalable fault-tolerant quantum computing pursued by industry and academia. We abstract away surface code implementation details by using a minimal set of operations supported by the surface code via lattice-surgery. Our exposition is accessible to a reader not familiar with surface codes and fault-tolerant quantum computing.Comment: 27 page