Meeting 2026 08 24

Meeting - August 24, 2026

• Date: Monday, August 24, 2026
• Time: (Slot #2) 7 pm - 8 pm US Eastern Daylight Time (View Meeting Time in Your Timezone)
• Location: Virtual Meeting.
• Meeting Link: openqse.org/captcha
• Meeting title: Open QHPC Software Ecosystem (openQSE) slot 2
• Attendance report window: 6:56:31 pm - 8:05:44 pm US Eastern Daylight Time
• Meeting duration from attendance report: 1h 9m 12s
• Transcript duration: 1h 3m 24s
• Attended participant records: 30
• Average attendance time: 59m 1s

Upcoming meetings

• Next: Monday, August 31, 2026 @ (Slot #1) 12 pm - 1 pm US Eastern Daylight Time (View Meeting Time in Your Timezone)

Agenda

• Presentation: Quantum algorithms for fluid dynamics PDE solvers and HPC-quantum integration patterns - Murali Gopalakrishnan Meena, Oak Ridge National Laboratory
• Discussion and Q&A on circuit synthesis, QPU/HPC stack requirements, variational workflow latency, distributed QPU architectures, and tensor-network approaches for nonlinear PDEs.

Attendance

Teams attendance listed 30 participant records. The table below consolidates a duplicate Andrea Delgado rejoin record.

Person	Institution
Amir Shehata	Oak Ridge National Laboratory (ORNL)
Laura Schulz	Argonne National Laboratory (ANL)
Jeffrey Heckey	Amazon
Wenji Wu	Lawrence Berkeley National Laboratory (LBNL)
Andrea Delgado	QBlox
Bran Radovanovic	Oak Ridge National Laboratory (ORNL)
Smriti Bajaj	Dell
Yoonho Park	IBM
Andy Stone	Hewlett Packard Enterprise (HPE)
Murali Gopalakrishnan Meena	Oak Ridge National Laboratory (ORNL)
Ryan Landfield	Oak Ridge National Laboratory (ORNL)
Gaurav Gyawali	Hewlett Packard Enterprise (HPE)
Michael Ferguson	Hewlett Packard Enterprise (HPE)
Alex Chernoguzov	Quantinuum
Josh Moles	Snoquera
Jiri Schindler	Independent
Yasuko Eckert	AMD
Yogesh Simmhan	Indian Institute of Science (IISc)
Jonathan Skone	LBNL/NERSC
Doug Oucharek	ORNL
Christian Heiter	Hewlett Packard Enterprise (HPE)
Claudio Siqueira de Carvalho	IBM
Thomas Naughton	Oak Ridge National Laboratory (ORNL)
Iman Elsayed	NVIDIA
Kevin K.	A&B
Hiroshi Horii	IBM
Aaron Lott	Hewlett Packard Enterprise (HPE)
Martin Schulz	Technical University of Munich (TUM)
Mina	Student

Executive Summary

• Murali Gopalakrishnan Meena presented ORNL/OLCF work on quantum algorithms for fluid dynamics PDEs, focusing on HPC-quantum integration requirements rather than claiming current quantum advantage.
• The talk used large-scale fluid dynamics simulation as the motivating workload. Production simulations can involve trillions of grid points and require tens to hundreds of terabytes per snapshot, making memory movement, data representation, and solver decomposition central concerns.
• Four algorithm families were discussed: HHL-style quantum linear solving, variational quantum linear solving, an SVD-based quantum linear solver, and tensor-network-based methods for nonlinear PDE terms and time evolution.
• The recurring integration theme was that QPU execution time alone is not enough to evaluate usefulness. Classical preprocessing, state preparation, block encoding, circuit synthesis, transpilation, queue latency, shot count, post-selection, post-processing, and data movement all affect whether a PDE solver can use a QPU productively.
• The discussion identified stack requirements relevant to openQSE: GPU-accelerated circuit synthesis and transpilation, high-throughput linear algebra, close CPU/GPU/QPU scheduling, support for both submit-and-forget and variational workflows, and an orchestrator that can choose CPU, GPU, or QPU execution based on kernel complexity and expected advantage.
• No formal votes or decisions were recorded. Follow-up opportunities were identified around optimizer convergence, tensor-network-to-circuit compilation, QPU interface requirements for PDE solvers, and distributed CPU/GPU/QPU execution models.

Detailed Meeting Minutes

Opening

• Amir Shehata started the recording and transcription, thanked attendees, introduced Murali Gopalakrishnan Meena from Oak Ridge National Laboratory, and handed over the meeting for the technical presentation.
• Murali framed the presentation as a report on ongoing work with an OLCF/LCF working group studying fluid dynamics PDEs using quantum computing algorithms.
• The focus of the talk was the integration and implementation side of quantum algorithms for PDE workloads, especially how classical HPC resources and QPUs would need to interact.
• Murali explicitly stated that the talk was not intended to demonstrate or argue quantum advantage. The purpose was to describe current efforts, assess applicability, and invite feedback and collaboration from the openQSE community.

Scientific Motivation: Fluid Dynamics Workloads

• Murali introduced fluid dynamics as a representative high-end simulation workload where extreme spatial and temporal resolution drives both compute and data-management costs.
• As a motivating example, he described OLCF work on stably stratified turbulence, a class of fluid flow relevant to ocean and atmospheric dynamics where density variations affect heat and salinity mixing.
• One example simulation required more than 6 trillion grid points to resolve the domain. A single saved snapshot of the variables for that case corresponds to more than 100 TB of data.
• Murali noted that this is not the largest class of simulations run on Frontier. Some simulations involve more than 400 trillion grid points, and some high-resolution snapshots can approach a quarter petabyte.
• The broader point was that fluid dynamics applications stress both computational complexity and data storage. This creates motivation to investigate machine learning and quantum computing alongside traditional HPC solvers.
• Murali described the existing HPC solver as the central workhorse. The team is also using machine learning for surrogate modeling and data compression, while assessing whether quantum computing can help with computational complexity or storage challenges.

PDE Problem Framing

• The presentation focused on incompressible-flow PDEs, which solve for quantities such as velocity and pressure.
• Murali emphasized that the equations include both linear and nonlinear terms, and that this distinction matters when selecting quantum algorithms.
• A simple numerical path was described: discretize the physical domain into pixels or voxels, project the PDE into local approximations such as finite differences, and rearrange the resulting equations into an AX = B linear-system form.
• Murali noted that this simple AX = B formulation is useful for algorithm discussion but is not how large practical fluid simulations are implemented. Once problem sizes grow beyond small grids, forming and storing the full matrix becomes impractical.
• The talk focused on continuum simulation approaches rather than lattice approaches, because continuum formulations apply broadly as fluid flows become more complex.
• Quantum linear solvers were presented as one route for linearized PDE components because they can promise favorable time-complexity scaling. The limitation is that linearizing nonlinear fluid equations can make the solution space difficult to handle.
• The alternative is to address nonlinear terms directly. Murali described this area as important but less mature and less general than the work on linear quantum solvers.

ORNL Working Group Activities

• The working group is pursuing solver development across multiple quantum algorithm families.
• The team is implementing algorithms in different SDKs because the quantum software ecosystem is evolving quickly and portability is a practical concern.
• The team benchmarks on simulators, HPC systems, and quantum hardware to understand which device types, qubit mappings, and topology constraints are suitable for these workloads.
• Current work includes hybrid approaches and benchmarking some methods against a quantum framework being developed by Amir.
• The group is also exploring PDE applications beyond turbulence, including biology-related PDE problems.
• Workforce development is part of the effort because quantum algorithms for fluid dynamics remain nascent within the fluid dynamics community.

Algorithm and Integration Overview

Algorithm	Role in the talk	Integration pattern	Main concerns discussed
HHL-style quantum linear solver	Fault-tolerant-oriented solver for AX = B kernels	Classical problem setup and circuit synthesis, QPU execution, then post-selection and reconstruction	QPE depth, matrix encoding, state preparation, circuit synthesis, full-state tomography, post-processing
Variational quantum linear solver (VQLS)	Near-term hybrid solver for linear systems	Classical optimizer updates parameters, QPU estimates cost, expectation values return to optimizer	Millions of circuits per optimizer iteration, queue latency, convergence, ansatz choice, LCU term count
SVD-based quantum linear solver	Hybrid solver that moves matrix preprocessing to classical SVD	Classical matrix assembly and SVD, arbitrary-unitary synthesis, B-vector state preparation, QPU run, post-processing	SVD cost, arbitrary-unitary synthesis, deep circuits, node memory limits
Tensor-network methods	Route toward nonlinear PDE terms and full time evolution	Classical MPS/MPO construction and compression, then potential quantum-circuit synthesis and time evolution	MPS/MPO-to-circuit conversion, long time-evolution circuits, nonlinear-term representation

• Murali explained that the first three algorithms are different approaches to solving the same or similar linear-solve kernel. Whether that kernel represents the whole simulation or only one component depends on the application workflow.
• The tensor-network direction differs because it is intended to address nonlinear terms and potentially the full time-evolution simulation.
• Across all methods, the relevant integration question is where a QPU sits in a larger HPC workflow and what runtime, compilation, and scheduling capabilities the stack must expose.

HHL-Style Quantum Linear Solver

• Murali introduced HHL as a canonical quantum algorithm for solving systems of linear equations with a provable complexity advantage under appropriate assumptions.
• The algorithm represents the solution in the eigenbasis of the A matrix. Quantum phase estimation (QPE) is used to obtain the relevant spectral information.
• The resulting QPE component creates deep circuits. The complexity depends on properties of the matrix, including sparsity, condition number, and the approximation order used for the eigenbasis.
• For fluid dynamics, an additional complication is that the A matrix is not Hermitian. Murali described augmenting the representation, which increases the qubit requirement.
• The team implemented the method for a canonical flow problem between two parallel plates, a setting Murali connected to microfluidics as an intuitive example.
• Before reaching QPU execution, the team encountered a bottleneck in circuit generation. For larger problem sizes, generating the QPE circuits became the limiting step.
• The original circuit-generation timings discussed in the meeting measured circuit synthesis time, not quantum execution time. Murali clarified that the measured timings came from serial generation on a laptop; running the same serial process on Frontier would not solve the issue by itself.
• The team is working on CPU-parallel and GPU-parallel approaches for circuit generation.
• To reduce QPE cost, the team developed an optimized implementation that removes redundant repetitions in controlled-unitary operations. Instead of repeatedly synthesizing powers of a base unitary, the implementation uses classical preprocessing and matrix exponentiation to synthesize one arbitrary unitary per controlled operation.
• This changes the controlled-unitary growth pattern from exponential repetition to a more linear structure, reducing both circuit-generation time and circuit depth for the tested cases.
• Murali reported that this optimization enabled small hardware executions that were not feasible with the baseline implementation. Without the optimization, the team could barely obtain usable results for a 2 x 2 problem; with the optimization, they could scale somewhat further and test across multiple hardware systems.
• The largest examples discussed were still small from a classical CFD perspective, but useful for studying the integration pattern and hardware sensitivity.

HHL Hardware Observations

• Murali described benchmark results across multiple hardware systems and device types.
• The tested circuits were small enough to fit on current devices; examples discussed used approximately 5 and 7 qubits for the particular cases shown.
• The optimization reduced two-qubit operations, which improved hardware fidelity. Murali stated that simulator fidelity was largely unchanged, while hardware fidelity improved because the physical circuit became easier to execute.
• Fidelity for the HHL experiments was computed from full-state tomography of the reconstructed solution vector for the AX = B problem.
• The results supported the team's hypothesis that all-to-all connectivity is valuable for these workloads, especially because of the controlled-unitary operations in QPE.
• Trapped-ion systems generally performed better in the comparison shown. Murali also noted an outlier superconducting system with effective all-to-all behavior, identified in the transcript as IQM Sirius, which supported the same connectivity hypothesis.

HHL Integration Requirements

• Murali characterized the HHL-style workflow as mostly one directional:
  • assemble the PDE problem classically;
  • perform classical/quantum preprocessing such as block encoding, state preparation, and circuit synthesis;
  • submit the resulting circuit to quantum hardware;
  • post-process the readout into the reconstructed solution.
• Because the workflow does not require optimizer feedback or mid-circuit interaction, it can be treated as a submit-and-forget workload. Queue time is less damaging than it is for variational methods, although total turnaround time still matters.
• The caveat is that full-state tomography can require many shots. Murali stated that some hardware systems capped shots around 20,000, while other runs pushed toward or above 100,000.
• For scalability, Murali argued that the application side needs to identify single-observable or global-observable use cases, so the solver does not require full-state tomography for every kernel.
• The stack requirements identified for HHL-style work were GPU-accelerated circuit synthesis, GPU-accelerated transpilation, and accurate execution on fault-tolerant or otherwise sufficiently reliable hardware.
• Murali emphasized that a single standalone QPU or standalone GPU approach will not scale to realistic fluid dynamics problem sizes.

Variational Quantum Linear Solver

• Murali then moved to near-term variational algorithms that can run on current devices with much shallower circuits than HHL-style fault-tolerant circuits.
• The variational quantum linear solver formulates AX = B as an optimization problem. A parameterized circuit ansatz represents a candidate solution X.
• The quantum computer estimates cost terms, and a classical optimizer updates the circuit parameters. The cost is based on the distance between the computed B vector and the target B vector.
• Murali compared this structure to other variational workflows such as VQE and QAOA: repeated QPU evaluations are interleaved with classical parameter updates.
• He noted that state-of-the-art demonstrations on simple model problems can reach very large simulated matrix dimensions using tensor-network simulation, and smaller examples on hardware.
• For realistic fluid dynamics problems, two major issues appeared:
  • even with shallow circuits, realistic encodings can require millions of circuits per optimizer iteration;
  • there is no general method for choosing the best ansatz for the application.
• The circuit executions are embarrassingly parallel. The team used asynchronous execution across GPU simulators and observed near-ideal strong scaling for small cases until the GPU became overloaded.
• Murali stressed that this parallel execution does not solve the fundamental circuit-count problem, but it does show what would be needed if future systems had many QPUs available.
• The team is exploring circuit pruning to reduce the number of circuits. In response to a question, Murali clarified that this is not circuit knitting; the matrix is encoded as a linear combination of unitaries, and the team prunes LCU terms according to a threshold.
• The team also evaluates ansatz expressibility and entangling capability as part of ansatz characterization.
• For the stack, the key issue is queue latency. Variational algorithms need close scheduling between CPU, GPU, and QPU because the optimizer loop depends on repeated low-latency feedback.
• Murali said the team is not yet focused on optimizer convergence itself and would welcome community expertise in that area.
• Another direction under consideration is replacing some circuit evaluations and parameter search with a classically trained generative AI model. This could reduce the number of QPU calls, but would require model-parallel classical resources close to the QPU if it is to generalize well.

SVD-Based Quantum Linear Solver

• The SVD-based method was presented as a response to a common bottleneck in the previous two approaches: encoding the matrix A.
• In HHL, QPE drives very deep circuits. In VQLS, matrix encoding through LCU terms can drive a very large circuit count.
• The SVD-based method performs classical preprocessing of the A matrix using singular value decomposition. The result is a unitary representation that can be encoded or synthesized for the quantum circuit.
• The quantum part then applies the derived unitary to the prepared B vector to obtain the solution representation.
• Murali described this approach as enabling larger application examples than the HHL and VQLS demonstrations. He specifically discussed larger grid examples and arbitrary-body flow examples as cases that the earlier approaches could not practically reach in their simulator studies.
• The tradeoff is that the arbitrary unitary must still be synthesized into a circuit, and that synthesis dominates the classical preprocessing and compilation cost. The circuit depth also becomes large.
• Although the method is hybrid, Murali stated that it still points toward fault-tolerant hardware because of the depth and accuracy requirements.
• The classical SVD step has worst-case cubic complexity and can consume a substantial portion of the workflow time.
• Compared with HHL, the SVD-based method can reduce the qubit requirement. Murali described the circuit size as matching the number of qubits needed to encode or prepare the B vector state, rather than the larger qubit overhead required by HHL.
• Stack needs for this method include high-throughput linear algebra packages, GPU-accelerated circuit synthesis, GPU-accelerated transpilation, and careful attention to how much problem data can fit on a single classical node for preprocessing and state preparation.

Tensor-Network Approach for Nonlinear PDE Terms

• Murali introduced the tensor-network work as application-driven because fluid dynamics is nonlinear and the first three algorithms primarily solve linear systems.
• The goal is to represent states, operators, nonlinear terms, and time evolution in a form that can eventually map to quantum circuits.
• The state encoding uses matrix product states (MPS). A high-dimensional tensor representing variables such as velocity or pressure is converted into a chain of smaller tensors.
• This representation can reduce space complexity by compressing the effective dimensionality through the bond dimension.
• Operators can similarly be represented as matrix product operators (MPO), reducing the storage burden for operators that would otherwise appear as large dense matrices.
• Murali explained that the nonlinear term can be constructed through elementwise operations involving the state and operator representations.
• The current demonstrations are classical tensor-network demonstrations. The work has not yet been run on quantum hardware because the main missing step is conversion of MPS/MPO operations into quantum circuits.
• Possible synthesis routes include LCU-based techniques for encoding tensor-network operations into circuits.
• Once a quantum-equivalent circuit exists, many of the same challenges seen in HHL return: circuit synthesis, block encoding, state preparation, and post-processing. Tensor-network approaches also add very long time-evolution circuits.
• Time evolution was described as combining state preparation with MPO-based operations and applying time-evolution methods such as Trotter-Suzuki or fast forwarding.
• Murali clarified that this approach differs from the first three because it aims at the full simulation and nonlinear dynamics, not only an isolated linear-solve kernel.

Practical Scale and System Architecture

• Murali closed the presentation by discussing what must be addressed for practical fluid-flow problems.
• He emphasized that practical fluid problems are not 4 x 4, 8 x 8, or even 2^20 scale. The state sizes relevant to the largest simulations can be on the order of 2^42 to 2^45.
• Forming a full A matrix of size such as 2^40 x 2^40 is impossible in memory, and attempting to block encode or synthesize circuits from such a full matrix leads to impractically deep circuits.
• The practical route must mirror classical HPC fluid solvers: never assemble the full global matrix, discretize and decompose the domain, and distribute the problem across nodes.
• Murali argued that problem size alone should not determine whether a kernel is offloaded to CPU, GPU, or QPU. The relevant criterion should be kernel complexity and whether the algorithm offers polynomial or super-polynomial benefit in that part of the workflow.
• The proposed architecture is not a monolithic QPU next to an HPC machine. Instead, Murali described a distributed model where each node has CPU, GPU, and QPU resources available for different parts of the decomposed problem.
• In this model, HPC continues to handle what it already does well: halo exchange, ghost-cell communication, global reductions, scatter/gather operations, load balancing, and distributed orchestration.
• QPUs would accelerate selected kernels where quantum execution is beneficial and where state preparation, communication, and readout costs do not erase the benefit.
• Communication pattern is an important determinant. Nearest-neighbor communication for ghost cells may be more feasible in nearer-term architectures. Workloads that require all-to-all transposes are much harder and can dominate the runtime in some fluid simulations.
• Murali posed an open question to the openQSE community: what must a QPU expose so that a PDE solver can use it as an effective accelerator?
• He described the need for an orchestrator that can choose CPU, GPU, or QPU execution dynamically based on the kernel and system state.
• The orchestrator model implies concurrent CPU/GPU/QPU scheduling rather than isolated batch execution.
• Mid-circuit measurement was identified as important for future time-stepping algorithms. With mid-circuit measurement and classical feedback, a solver may be able to time-evolve kernels based on information from the classical side without reinitializing state preparation at every time step.
• Murali concluded that a facility stack should support both submit-and-forget workflows, such as fault-tolerant HHL-style runs, and latency-sensitive variational workflows.
• Murali also mentioned a Quantum Week workshop on quantum computing for PDEs and noted ongoing efforts on both AI-for-quantum and quantum-for-AI aspects.

Discussion and Q&A

• Laura Schulz asked whether the four algorithms were all required together for the overall solution or whether they were separate approaches. Murali answered that the first three can solve the same kind of linear-solve kernel and should be viewed as alternative approaches for that kernel. Whether that kernel represents the full problem or only part of a larger simulation is application dependent. The tensor-network approach is different because it targets full time evolution and nonlinear simulation components.
• Michael Ferguson asked whether the preprocessing and post-processing blocks would dominate performance even if the QPU itself executed extremely quickly. Murali agreed that this is a major issue across the workflows. He emphasized that both the front-end work, such as circuit synthesis and encoding, and the back-end work, such as post-selection and scalable reconstruction, can become limiting.
• Kevin K. asked how to interpret the timing axis shown for HHL circuit generation and whether the numbers depended on quantum hardware assumptions. Murali clarified that the timings were not quantum runtime measurements; they measured classical circuit synthesis before execution. The timings were from serial generation on a laptop, and the immediate need is parallel CPU/GPU circuit-generation capability.
• Gaurav Gyawali asked how the optimized QPE implementation reduced circuit depth. Murali explained that repeated powers of controlled unitaries are compressed through classical preprocessing and matrix exponentiation, so each controlled operation synthesizes a single arbitrary unitary rather than repeatedly expanding the base operation. Gaurav noted that the depth interpretation should be discussed further.
• Wenji Wu asked whether the algorithms fit on available quantum hardware and how the reductions affected fidelity. Murali said the demonstrated circuits were small, with example cases around 5 and 7 qubits. The reduction in two-qubit operations improved hardware fidelity, while simulator fidelity remained essentially unchanged. Fidelity was computed from full-state tomography of the reconstructed solution vector.
• Michael Ferguson asked whether HHL was being run with one shot. Murali clarified that "single pass" referred to the absence of interaction between shots or optimizer iterations, not to one physical shot. The team used shot counts that depended on hardware limits, including caps around 20,000 shots on some systems and attempts above 100,000 shots on others.
• Wenji Wu asked who handles transpilation or transformation for the different quantum systems. Murali said GPU-accelerated transpilation was an aspiration for the stack, while current tests used Qiskit optimization levels and backend-provided tooling for the tested systems.
• Gaurav Gyawali asked whether the VQLS circuit-pruning approach was related to circuit knitting. Murali clarified that it was not circuit knitting. The method prunes LCU terms used to encode the non-Hermitian, non-unitary A matrix according to a threshold.
• Wenji Wu asked whether the distributed model with multiple QPUs requires direct QPU-to-QPU interaction, remote gates, or fully distributed quantum computing. Murali responded that the immediate model could use classical communication: run a kernel locally, measure/read out, and communicate boundary information to neighboring nodes classically. For more scalable future implementations, direct quantum-side communication may be needed.
• Wenji Wu followed up to confirm that the large problem is split into subproblems and that each device works mostly independently until communication is needed. Murali confirmed the analogy with classical distributed computing, where each accelerator works locally until an all-reduce, scatter, halo exchange, or related communication phase is required.
• Gaurav Gyawali asked, in the tensor-network context, whether compiling MPS/MPO structures into a quantum circuit means the problem has already been solved classically. Murali answered that the classical tensor-network representation provides space compression, but long time evolution can still be infeasible classically because of time complexity and entanglement/bond-dimension growth. The potential quantum advantage would come from applying the time evolution on a quantum computer after the circuit-synthesis challenge is solved.
• Gaurav noted that HPE has related work on HPC-optimized circuit compilation from MPS, MPO, and other tensor-network representations, and offered to discuss possible collaboration. Murali welcomed that follow-up.
• Amir closed the meeting at the top of the hour, thanked Murali and the attendees, and ended the session.