We develop a workflow decomposing a molecule into fragments via quantum embedding and simulating them with a heterogeneous quantum-classical (HQC) method. We sample fragment electronic configurations on two 156-qubit quantum processors (ibm_cleveland, ibm_kobe), using up to 94 qubits, running 21,006 circuits for over 239 hours, collecting 3.0 · 10^9 measurement outcomes – the most resource-intensive HQC computation for quantum chemistry to date. We compute fragment wavefunctions via optimized subspace diagonalization on supercomputers Fugaku, Miyabi-G, and ROQUO, achieving 72.5% parallel efficiency with scalable distributed linear algebra kernels. We simulate two protein-ligand complexes spanning dispersion- and electrostatics-dominated regimes (11,608, 12,635 atoms), demonstrate >40× increase in system size and up to 210× improvement in accuracy over previous state-of-the-art, with HQC matching coupled-cluster (CCSD) accuracy in fragment energies. We present the first HQC protein-ligand binding prediction using a mixed-basis set and an automated end-to-end workflow enabling practical HQC calculations of large protein systems.

Selected Basis Diagonalization (SBD) plays a central role in Sample-based Quantum Diagonalization (SQD), where iterative diagonalization of the Hamiltonian in selected configuration subspaces forms the dominant classical workload. We present a GPU-accelerated implementation of SBD using the Thrust library. By restructuring key components – including configuration processing, excitation generation, and matrix-vector operations – around fine-grained data-parallel primitives and flattened GPU-friendly data layouts, the proposed approach efficiently exploits modern GPU architectures. In our experiments, the Thrust-based SBD achieves up to ∼40× speedup over CPU execution and substantially reduces the total runtime of SQD iterations. These results demonstrate that GPU-native parallel primitives provide a simple, portable, and high-performance foundation for accelerating SQD-based quantum-classical workflows.

Quantum computers are becoming practical for computing numerous applications. However, simulating quantum computing on classical computers is still demanding yet useful because current quantum computers are limited because of computer resources, hardware limits, instability, and noises. Improving quantum computing simulation performance in classical computers will contribute to the development of quantum computers and their algorithms. Quantum computing simulations on classical computers require long performance times, especially for quantum circuits with a large number of qubits or when simulating a large number of shots for noise simulations or circuits with intermediate measures. Graphical processing units (GPU) are suitable to accelerate quantum computer simulations by exploiting their computational power and high bandwidth memory and they have a large advantage in simulating relatively larger qubits circuits. However, GPUs are inefficient at simulating multi-shots runs with noises because the randomness prevents highly parallelization. In addition, GPUs have a disadvantage in simulating circuits with a small number of qubits because of the large overheads in GPU kernel execution. In this paper, we introduce optimization techniques for multi-shot simulations on GPUs. We gather multiple shots of simulations into a single GPU kernel execution to reduce overheads by scheduling randomness caused by noises. In addition, we introduce shot-branching that reduces calculations and memory usage for multi-shot simulations. By using these techniques, we speed up x10 from previous implementations.

Classical computers require large memory resources and computational power to simulate quantum circuits with a large number of qubits. Even supercomputers that can store huge amounts of data face a scalability issue in regard to parallel quantum computing simulations because of the latency of data movements between distributed memory spaces. Here, we apply a cache blocking technique by inserting swap gates in quantum circuits to decrease data movements. We implemented this technique in the open source simulation framework Qiskit Aer. We evaluated our simulator on GPU clusters and observed good scalability.

Quantum computing simulation on a classical computer is difficult due to the exponential runtime and memory overhead. Previous work addresses the difficulty by utilizing multiple Graphical Processing Units (GPUs) and multi-node computers. GPUs are efficient for handling runtime issues but have limited total accessible memory space. Meanwhile, the memory of a multi-node computer can be scaled to the petabytes order, but its bandwidth for access from host computers (CPUs) is narrow. To simultaneously accelerate simulation and enlarge the total memory space, we propose a heterogeneous parallelization approach by combining GPUs and CPUs. Our simulator allocates memory to the GPUs first, and then to the CPUs. It thus accelerates simulation by using the full capabilities of the GPUs if memory for the simulation fits in the GPUs on a cluster. Allocating memory to the CPUs reduces benefits of the GPUs but enlarges the capacity of qubits in the simulation. In such case, it can exploit the memory of the GPUs to add one more qubit in the simulation if the size of memory in a node is the power of two (such as 512GB). We show empirical performance evaluations of our simulator in a distributed environment of POWER9.

As supercomputers are shifting from peta-scale to exa-scale, computers with accelerators such as GPUs, MICs and FPGAs have become one of the big trends of supercomputer because of their low energy consumption and high density.Now IBM's POWER processor has quite new power, Nvidia's Tesla GPU brings huge computational capability.It is important for us to understand how this new POWER+GPU environment brings power to the actual applications in the early stage.We implemented Wilson-Dirac operator and BiCGStab solver using CUDA7.0 on the POWER+GPU cluster and evaluated the performance.

We describe our experience on the multipurpose C++ code IroIro++ designed for JLQCD to run on the BG/Q installation at KEK. We discuss some details on the performance improvements specific for the IBM Blue Gene Q.

This paper provides a short overview of the IBM Blue Gene® project and an introduction to all of the papers in this issue of the IBM Journal of Research and Development.

Lattice Quantum Chromodynamics (QCD) is one of the most challenging applications running on massively parallel supercomputers. To reproduce these physical phenomena on a supercomputer, a precise simulation is demanded requiring well optimized and scalable code. We have optimized lattice QCD programs on Blue Gene family supercomputers and shown the strength in lattice QCD simulation. Here we optimized on the third generation Blue Gene/Q supercomputer; i) by changing the data layout, ii) by exploiting new SIMD instruction sets, and iii) by pipelining boundary data exchange to overlap communication and calculation. The optimized lattice QCD program shows excellent weak scalability on the large scale Blue Gene/Q system, and with 16 racks we sustained 1.08 Pflop/s, 32.1% of the theoretical peak performance, including the conjugate gradient solver routines.

Torus networks are commonly used for massively parallel computers, its performance often becomes the constraint on total application performance. Especially in an asymmetric torus network, network traffic along the longest axis is the performance bottleneck for all-to-all communication, so that it is important to schedule the longest-axis traffic smoothly. In this paper, we propose a new algorithm based on an indirect method for pipelining the all-to-all procedures using shared memory parallel threads, which (1) isolates the longest-axis traffic from other traffic, (2) schedules it smoothly and (3) overlaps all of the other traffic and overhead for the all-to-all communication behind the longest-axis traffic. The proposed method achieves up to 95% of the theoretical peak. We integrated the overlapped all-to-all method with parallel FFT algorithms. And local FFT calculations are also overlapped behind the longest-axis traffic. The FFT performance achieves up to 90% of the theoretical peak for the parallel 1D FFT.

We introduce a parallelized molecular dynamics (MD) simulation adapted for the IBM Blue Gene/L supercomputer. We begin by describing the Parallel MD code. Next we discuss how Parallel MD was tuned for Blue Gene/L. We then show the results for some test targets, related to disease associated proteins, that we have run on Blue Gene/L and the efficiency we have achieved. Finally, we mention some future directions that we envisage undertaking as a continuation of this project.

We propose an efficient and exact method for the adaptive sign detection of 4×4 determinants using a standard arithmetic unit. The entities of determinants are variable length integers (integers of arbitrary bit length). The integers are expressed in 16-bit data units, and the sign detection is reduced to the computation of 4×4 determinants of 16-bit integers. To accelerate the computation, the calculation is performed by using a standard arithmetic unit. We have implemented our method and confirmed that it significantly improves the computation time of 4×4 determinants. The method can be applicable to many geometric algorithms that need the exact sign evaluation of 4×4 determinants, especially to construct robust geometric algorithms.

グラフデータの視覚化技術は，近年活発に研究が進められており，金融・交通・通信・社会組織・科学・計算機システム・インターネットなど，非常に幅広い分野のデータ分析およびデータ監視の目的での実用が報告されている．グラフデータの視覚化における最も大きな問題は，「グラフを誤読させない適切なノードの画面配置を，自動的に実現する」という問題である．この問題を解決するために，ノードに分子間力モデル，アークにバネモデルを適用して，運動方程式によって良質なノード配置結果を得る手法が提案されている．本論文では，上記のような「力学モデルを用いたグラフデータの画面配置手法」の改良手法および階層型グラフデータへの拡張手法を提案する．本手法は，ノードを１個ずつ配置するインクリメンタルなアルゴリズムにより，配置結果を改善するとともに，計算時間の増加を抑えることに成功している．また本論文では，上記手法を用いたウェブサイトの視覚化結果を提示する．本手法では，ウェブサイトを構成するウェブページをノード，ウェブページ間のハイパーリンクをアークとして，またウェブページのディレクトリ階層を参照してウェブページを階層型データに格納することにより，ウェブサイトを階層型グラフデータとして表現する．この階層型グラフデータを上記手法により画面配置し，個々のウェブページをサムネイル画像で表示することにより，ウェブサイトの全体像を表現する．