# An Artificial Neuron for Enhanced Problem Solving in Large Language Models

Sumedh Rasal
Georgia Institute of Technology
Chicago, IL
<EMAIL_ADDRESS>

###### Abstract

Recent advancements in artificial intelligence have propelled the capabilities
of Large Language Models (LLMs), yet their ability to mimic nuanced human
reasoning remains limited. This paper introduces a novel conceptual
enhancement to LLMs, termed the "Artificial Neuron," designed to significantly
bolster cognitive processing by integrating external memory systems. This
enhancement mimics neurobiological processes, facilitating advanced reasoning
and learning through a dynamic feedback loop mechanism. We propose a unique
framework wherein each LLM interaction—specifically in solving complex math
word problems and common sense reasoning tasks—is recorded and analyzed.
Incorrect responses are refined using a higher-capacity LLM or human-in-the-
loop corrections, and both the query and the enhanced response are stored in a
vector database, structured much like neuronal synaptic connections. This
"Artificial Neuron" thus serves as an external memory aid, allowing the LLM to
reference past interactions and apply learned reasoning strategies to new
problems.

Our experimental setup involves training with the GSM8K dataset for initial
model response generation, followed by systematic refinements through feedback
loops. Subsequent testing demonstrated a 15% improvement in accuracy and
efficiency, underscoring the potential of external memory systems to advance
LLMs beyond current limitations. This approach not only enhances the LLM’s
problem-solving precision but also reduces computational redundancy, paving
the way for more sophisticated applications of artificial intelligence in
cognitive tasks. This paper details the methodology, implementation, and
implications of the Artificial Neuron model, offering a transformative
perspective on enhancing machine intelligence.

##  1 Introduction

The advent of artificial intelligence has ushered in an era where Large
Language Models (LLMs) like GPT-2 through GPT-4 [1] [2] have demonstrated
unprecedented capabilities in language understanding and problem-solving [3]
[4] [5] [6] [7] [8] [9]. These models have progressively bridged the gap
between computational text processing and genuine linguistic comprehension,
enhancing their utility across a spectrum of applications, from simple task
automation to complex problem resolution [10] [11]. Despite these
advancements, the quest towards achieving a fully autonomous LLM, capable of
exhibiting human-like reasoning and decision-making, remains elusive [12].

This paper introduces the concept of the "Artificial Neuron" as a strategic
enhancement for LLMs, aiming to replicate aspects of human cognitive processes
through the integration of an external memory module. Traditional LLMs, while
proficient in language tasks, cannot often draw on past experiences or adapt
their responses based on previously encountered contexts. The Artificial
Neuron is designed to address these shortcomings by enabling LLMs to store,
recall, and utilize past interactions in their decision-making processes, much
like the synaptic activities in the human brain [13] [14] [15].

In exploring whether we can endow LLMs with a form of artificial wisdom, this
study seeks to define and operationalize wisdom within the realm of artificial
intelligence. Wisdom, in this context, extends beyond mere data retrieval to
encompass the nuanced application of knowledge and experience in problem-
solving. The flexibility inherent in the transformer architecture of LLMs
allows for linguistic adaptability, yet it does not inherently equip these
models with the depth of understanding necessary to discern the subtleties of
language usage or to anticipate the implications of newly acquired
information.

The introduction of an Artificial Neuron aims to revolutionize this landscape
by providing a mechanism through which LLMs can enhance their reasoning skills
[16] [17] [18] [19] [20] [21] [22] [23] [24]. This paper will detail a novel
approach to supplementing LLMs with external memory, thus enabling them to
learn from both their training data and their interactive experiences. By
employing past encounters as templates for current problem-solving, the
Artificial Neuron seeks to improve the accuracy and relevance of LLM
responses, ultimately bridging the gap between current capabilities and the
potential for true artificial general intelligence [25] [26] [27].

Our proposed methodology deviates from traditional training methods, focusing
instead on building an external memory that aids the LLM in addressing complex
math word problems and common sense reasoning challenges. Initially, we
collect responses from the LLM using datasets comprised of math problems and
common sense questions, documenting both the answers and the LLM’s rationale
in a vector database. Incorrect responses are identified and refined either
through further consultations with the GPT-4 model or via human intervention,
ensuring that only corrected answers are stored.

Upon completion of these revisions, the enriched external memory is integrated
into the LLM’s operational framework. When the LLM encounters a new problem,
it performs a semantic search within the vector database to identify the top
three similar past scenarios. These records, detailing the strategies
previously employed, guide the LLM in formulating its approach to the new
question, utilizing a chain-of-thought prompt style based on the most relevant
templates.

Adopting a "learning by cases" strategy, combined with chain-of-thought
reasoning, we enhance the capabilities of a GPT-3.5-turbo model by equipping
it with this strategic external memory. The resultant outputs from this
augmented version of the GPT-3.5-turbo are promising and suggest significant
improvements over its predecessors. Our approach outlines:

  * •

The utilization of a vector database to meticulously record actions performed
by the LLM.

  * •

A mechanism to evaluate and amend these records, ensuring that they not only
reflect successful outcomes but also incorporate corrections where necessary.

  * •

A utility function that leverages these enriched records to set contextually
appropriate prompts, thereby elevating the LLM’s baseline accuracy and
performance.

This framework not only enhances the accuracy and efficiency of LLMs but also
bridges the gap towards achieving a more nuanced, context-aware artificial
intelligence.

##  2 Methodology

The methodology presented in this paper revolves around the innovative concept
of the "Artificial Neuron" for Large Language Models (LLMs), a structured
external memory system designed to enhance the reasoning abilities and
contextual understanding of AI in complex problem-solving scenarios. The
approach is delineated into distinct phases: setup, interaction, error
correction, and performance enhancement through a continuous learning cycle.

Phase 1: Setup and Integration of the Artificial Neuron

Model Configuration: We begin by configuring the LLM with an initial
architecture that includes an interface for integrating external memory
components. This setup allows the model to access and interact with the
Artificial Neuron, a specialized vector database designed to mimic synaptic
connections by storing and retrieving problem-solving experiences.

External Memory Initialization: The Artificial Neuron is populated initially
with a broad range of problem-solving scenarios drawn from selected datasets,
including GSM8K for math word problems and other datasets for common sense
reasoning tasks. Each entry in this memory unit contains the problem
statement, the LLM’s response, the reasoning process, and metadata about the
task.

Phase 2: Interactive Learning and Memory Utilization

Data Collection: As the LLM engages with new problem-solving tasks, each
interaction—question, proposed solution, and reasoning pathway—is logged. This
continuous data collection is critical for dynamically updating the Artificial
Neuron.

Semantic Search Mechanism: When presented with a new problem, the LLM performs
a semantic search within the Artificial Neuron to retrieve the most relevant
past interactions. This process is facilitated by advanced algorithms that
analyze the similarity between the new problem and stored entries, focusing on
both the problem’s nature and the contextual nuances of previous solutions.

Phase 3: Error Correction and Feedback Integration

Performance Analysis: Responses generated by the LLM are evaluated for
accuracy against established benchmarks or through expert review. Errors
identified in the LLM’s reasoning or outputs trigger a corrective feedback
loop.

Feedback Mechanism: Incorrect responses are corrected either through further
processing by a more advanced LLM model or via human intervention. The
corrected response, along with an analysis of the error and a detailed
explanation of the correct reasoning process, is then fed back into the
Artificial Neuron.

Memory Update: The Artificial Neuron is updated with this new information,
enhancing its database with both the corrected response and a revised
reasoning pathway. This update not only rectifies errors but also enriches the
future problem-solving capacity of the LLM.

Phase 4: Continuous Improvement and Testing

Iterative Learning: The process of interaction, error correction, and memory
enhancement is cyclic, with the LLM continuously refining its problem-solving
strategies based on accumulated experience stored in the Artificial Neuron.

Systematic Evaluation: Regularly scheduled evaluations measure the LLM’s
performance improvements over time. These assessments help fine-tune the
semantic search algorithms and the effectiveness of the feedback mechanisms,
ensuring that the Artificial Neuron remains a robust and dynamic aid in the
LLM’s cognitive processing.

This methodology not only proposes a practical framework for enhancing the
capabilities of LLMs through external memory but also illustrates a pathway
towards more sophisticated AI systems capable of learning and adapting from
their interactions, much like human cognitive processes.

##  3 Experiments

###  3.1 Enhancing Mathematical Reasoning with the Artificial Neuron

Datasets Utilized

1\. MAWPS: An extensive online repository of math word problems designed to
serve as a unified platform for evaluating algorithmic performance. This
dataset contains 3,320 problems sourced from previous studies, equipped with
tools that allow for the customization of datasets by adjusting lexical and
template overlaps, as well as filtering out ungrammatical problems. The
dynamic, online nature of MAWPS encourages continuous community contributions,
making it a rich resource for diverse mathematical challenges [28].

2\. SVAMP: A challenge set tailored for elementary-level math word problems,
presenting simple variations on arithmetic problems encapsulated in natural
language narratives. These problems test the model’s ability to interpret and
solve questions about unknown quantities based on described scenarios.

Training and Testing Procedure \- For both datasets, half of the problems were
allocated for training the Artificial Neuron, while the other half served as a
test set to evaluate the enhancement brought about by this novel approach.

\- During training, the Artificial Neuron was exposed to various problem-
solving scenarios where each interaction was logged, and incorrect responses
were subsequently corrected and enriched with detailed feedback.

\- In the testing phase, the LLM equipped with the Artificial Neuron tackled
new, unseen problems from the test set. The model’s responses were compared
against a control group, which consisted of the same LLM architecture without
the integration of the Artificial Neuron.

Results \- The experiments demonstrated a notable improvement of approximately
15% in solving accuracy over the baseline GPT-3.5-turbo model. This
enhancement underscores the efficacy of the Artificial Neuron in providing
contextual guidance and memory-based reasoning to tackle diverse and complex
math problems.

###  3.2 Complex Sequential Question Answering (CSQA)

Dataset Utilized

1\. CSQA Dataset: A newly introduced dataset designed to simulate real-world
interactions involving both question answering (QA) and dialogue systems. The
dataset comprises approximately 200,000 dialogues with a total of 1.6 million
turns. These dialogues are built around a large-scale knowledge graph (KG) and
require advanced inferencing to answer questions that often involve logical,
quantitative, and comparative reasoning.

Training and Testing Procedure \- Similarly, half of the CSQA dataset was used
to train the Artificial Neuron, focusing particularly on enhancing the model’s
ability to parse complex natural language queries, manage conversational
context, and utilize KGs effectively.

\- The remaining half of the dataset was used to evaluate the model’s
performance in a sequential question-answering setup that mirrors practical
conversational scenarios encountered by modern chatbots.

Results \- Preliminary results indicated that existing state-of-the-art
dialogue and QA models were inadequate in handling the complexity of the CSQA
dataset. However, the introduction of the Artificial Neuron significantly
improved the LLM’s ability to engage in coherent dialogue and answer questions
based on complex inferencing.

\- The experiment revealed an improvement in the model’s capability to clarify
ambiguities, resolve coreferences, and retrieve relevant subgraphs from the KG
for accurate responses.

These experiments validate the Artificial Neuron’s potential to substantially
enhance LLMs’ problem-solving capabilities across different domains. By
integrating experiences and learned strategies into an external memory, the
LLMs exhibited improved reasoning, adaptability, and accuracy in handling
complex, real-world tasks. This promising advancement invites further
exploration into extending these methods to broader AI applications,
potentially paving the way for more sophisticated cognitive abilities in
artificial intelligence systems.

##  4 Limitations

While the introduction of the Artificial Neuron represents a significant
advancement in the capabilities of Large Language Models (LLMs), this approach
is not without its limitations. Traditional methods for enhancing LLM accuracy
typically involve extensive retraining [29] on large datasets, which, while
effective, can be prohibitively expensive and time-consuming. Our methodology
circumvents these costs by enabling LLMs to learn from interactive experiences
stored within an external memory framework, reducing the need for frequent
retraining. However, this system introduces new challenges that must be
addressed:

Dependency on Manual Input: The current implementation relies heavily on
manual interventions for error identification and correction. Each instance
where the LLM fails to provide the correct answer or reasoning must be
manually reviewed and corrected, which is not only labor-intensive but also
limits the scalability of this approach.

Memory Integration: While integrating external memory with an LLM seems
straightforward, optimizing this memory for efficient retrieval and ensuring
it aligns seamlessly with the model’s operational framework requires further
development. The process of storing and retrieving relevant experiences from
the Artificial Neuron must be refined to prevent performance bottlenecks.

Quality Control: Ensuring the quality and relevance of the feedback stored in
the Artificial Neuron is crucial. Incorrect or misleading feedback could
reinforce poor reasoning habits in the LLM, potentially degrading its
performance over time.

##  5 Conclusion

This paper presents a pioneering approach to improving the reasoning abilities
and decision-making accuracy of Large Language Models through the use of an
external memory system, termed the Artificial Neuron. By allowing LLMs to
learn from their past interactions, we facilitate a form of experiential
learning that mimics human cognitive processes, enabling these models to
perform complex problem-solving tasks with greater accuracy.

Future iterations of this methodology should focus on automating the feedback
mechanisms. Developing algorithms that can automatically assess the
effectiveness of an LLM’s responses and provide accurate corrections will
enhance the scalability and efficiency of this approach. \- **Integration with
User Feedback**: Implementing systems that allow LLMs to adjust their
responses based on direct user feedback could provide a more dynamic learning
environment. This could involve real-time adjustments to responses based on
user interactions or satisfaction ratings.

We could explore the integration of the Artificial Neuron within a multi-agent
framework that could provide insights into how shared external memories
influence cooperative task-solving among multiple LLMs [30] [31] [32] [33]
[34] [35] [36] [37] [38] [39]. This could lead to advancements in how LLMs
collaborate and learn from each other, potentially opening new avenues for
developing more sophisticated AI systems.

By addressing these limitations and exploring these future directions, we can
continue to refine the Artificial Neuron concept and expand its applicability
across various domains, moving closer to creating LLMs that can operate with a
level of autonomy and reasoning complexity that mirrors human intelligence.

## References

  * [1] OpenAI.  Gpt-4 technical report. arxiv 2303.08774.  View in Article, 2:13, 2023.
  * [2] Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al.  Sparks of artificial general intelligence: Early experiments with gpt-4.  arXiv preprint arXiv:2303.12712, 2023.
  * [3] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al.  Language models are few-shot learners.  Advances in neural information processing systems, 33:1877–1901, 2020.
  * [4] Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, et al.  Emergent abilities of large language models.  arXiv preprint arXiv:2206.07682, 2022.
  * [5] Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, et al.  Llama: Open and efficient foundation language models.  arXiv preprint arXiv:2302.13971, 2023.
  * [6] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova.  Bert: Pre-training of deep bidirectional transformers for language understanding.  arXiv preprint arXiv:1810.04805, 2018.
  * [7] Shishir G Patil, Tianjun Zhang, Xin Wang, and Joseph E Gonzalez.  Gorilla: Large language model connected with massive apis.  arXiv preprint arXiv:2305.15334, 2023.
  * [8] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao.  React: Synergizing reasoning and acting in language models.  arXiv preprint arXiv:2210.03629, 2022.
  * [9] Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem.  Camel: Communicative agents for" mind" exploration of large scale language model society.  arXiv preprint arXiv:2303.17760, 2023.
  * [10] Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al.  Evaluating large language models trained on code.  arXiv preprint arXiv:2107.03374, 2021.
  * [11] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al.  Training language models to follow instructions with human feedback, 2022.  URL https://arxiv. org/abs/2203.02155, 13, 2022.
  * [12] Nazneen Fatema Rajani, Bryan McCann, Caiming Xiong, and Richard Socher.  Explain yourself! leveraging language models for commonsense reasoning.  arXiv preprint arXiv:1906.02361, 2019.
  * [13] Lawrence E Susskind and Jason Corburn.  Using simulations to teach negotiation: Pedagogical theory and practice.  Teaching negotiation: Ideas and innovations, pages 285–310, 2000.
  * [14] Pei Zhou, Andrew Zhu, Jennifer Hu, Jay Pujara, Xiang Ren, Chris Callison-Burch, Yejin Choi, and Prithviraj Ammanabrolu.  I cast detect thoughts: Learning to converse and guide with intents and theory-of-mind in dungeons and dragons.  In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 11136–11155, 2023.
  * [15] Andrea I Luppi, Pedro AM Mediano, Fernando E Rosas, Negin Holland, Tim D Fryer, John T O’Brien, James B Rowe, David K Menon, Daniel Bor, and Emmanuel A Stamatakis.  A synergistic core for human brain evolution and cognition.  Nature Neuroscience, 25(6):771–782, 2022.
  * [16] Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom.  Program induction by rationale generation: Learning to solve and explain algebraic word problems.  arXiv preprint arXiv:1705.04146, 2017.
  * [17] Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al.  Training verifiers to solve math word problems.  arXiv preprint arXiv:2110.14168, 2021.
  * [18] Subhro Roy and Dan Roth.  Solving general arithmetic word problems.  arXiv preprint arXiv:1608.01413, 2016.
  * [19] Ting-Rui Chiang and Yun-Nung Chen.  Semantically-aligned equation generation for solving and reasoning math word problems.  arXiv preprint arXiv:1811.00720, 2018.
  * [20] Aida Amini, Saadia Gabriel, Peter Lin, Rik Koncel-Kedziorski, Yejin Choi, and Hannaneh Hajishirzi.  Mathqa: Towards interpretable math word problem solving with operation-based formalisms.  arXiv preprint arXiv:1905.13319, 2019.
  * [21] Xinyun Chen, Chen Liang, Adams Wei Yu, Denny Zhou, Dawn Song, and Quoc V Le.  Neural symbolic reader: Scalable integration of distributed and symbolic representations for reading comprehension.  In International Conference on Learning Representations, 2019.
  * [22] Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant.  Commonsenseqa: A question answering challenge targeting commonsense knowledge.  arXiv preprint arXiv:1811.00937, 2018.
  * [23] Maarten Sap, Hannah Rashkin, Derek Chen, Ronan LeBras, and Yejin Choi.  Socialiqa: Commonsense reasoning about social interactions.  arXiv preprint arXiv:1904.09728, 2019.
  * [24] Arkil Patel, Satwik Bhattamishra, and Navin Goyal.  Are nlp models really able to solve simple math word problems?  arXiv preprint arXiv:2103.07191, 2021.
  * [25] Cheng-Han Chiang and Hung-yi Lee.  Can large language models be an alternative to human evaluations?  arXiv preprint arXiv:2305.01937, 2023.
  * [26] Sumedh Rasal and E. J. Hauer.  Navigating complexity: Orchestrated problem solving with multi-agent llms, 2024.
  * [27] Chirag Agarwal, Sree Harsha Tanneru, and Himabindu Lakkaraju.  Faithfulness vs. plausibility: On the (un)reliability of explanations from large language models.  ArXiv, abs/2402.04614, 2024.
  * [28] Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman.  Training verifiers to solve math word problems.  arXiv preprint arXiv:2110.14168, 2021.
  * [29] Sumedh Rasal and Sanjay Kumar Boddhu.  Beyond segmentation: Road network generation with multi-modal llms.  arXiv preprint arXiv:2310.09755, 2023.
  * [30] Tian Liang, Zhiwei He, Wenxiang Jiao, Xing Wang, Yan Wang, Rui Wang, Yujiu Yang, Zhaopeng Tu, and Shuming Shi.  Encouraging divergent thinking in large language models through multi-agent debate.  arXiv preprint arXiv:2305.19118, 2023.
  * [31] Chen Qian, Xin Cong, Cheng Yang, Weize Chen, Yusheng Su, Juyuan Xu, Zhiyuan Liu, and Maosong Sun.  Communicative agents for software development.  arXiv preprint arXiv:2307.07924, 2023.
  * [32] Anita Williams Woolley, Christopher F Chabris, Alex Pentland, Nada Hashmi, and Thomas W Malone.  Evidence for a collective intelligence factor in the performance of human groups.  science, 330(6004):686–688, 2010.
  * [33] Angeliki Lazaridou, Anna Potapenko, and Olivier Tieleman.  Multi-agent communication meets natural language: Synergies between functional and structural language learning, 2020.
  * [34] Laura Graesser, Kyunghyun Cho, and Douwe Kiela.  Emergent linguistic phenomena in multi-agent communication games, 2020.
  * [35] Jason Lee, Kyunghyun Cho, Jason Weston, and Douwe Kiela.  Emergent translation in multi-agent communication, 2018.
  * [36] Ning Wu, Ming Gong, Linjun Shou, Shining Liang, and Daxin Jiang.  Large language models are diverse role-players for summarization evaluation.  arXiv preprint arXiv:2303.15078, 2023.
  * [37] Sumedh Rasal.  Llm harmony: Multi-agent communication for problem solving, 2024.
  * [38] Carlos Jose Xavier Cruz.  Transforming competition into collaboration: The revolutionary role of multi-agent systems and language models in modern organizations, 2024.
  * [39] Emanuele Musumeci, Michele Brienza, Vincenzo Suriani, Daniele Nardi, and Domenico Daniele Bloisi.  Llm based multi-agent generation of semi-structured documents from semantic templates in the public administration domain.  ArXiv, abs/2402.14871, 2024.


# Spectrally Decomposed Diffusion Models for Generative Turbulence Recovery

Mohammed Sardar
School of Engineering
The University of Manchester
<EMAIL_ADDRESS>
&Alex Skillen
School of Engineering
The University of Manchester
&Małgorzata J. Zimoń1,2
1IBM Research Europe
2School of Mathematics,
The University of Manchester
&Samuel Draycott
School of Engineering
The University of Manchester
&Alistair Revell
School of Engineering
The University of Manchester

###### Abstract

We investigate the statistical recovery of missing physics and turbulent
phenomena in fluid flows using generative machine learning. Here we develop a
two-stage super-resolution method using spectral filtering to restore the
high-wavenumber components of a Kolmogorov flow. We include a rigorous
examination of generated samples through the lens of statistical turbulence.
By extending the prior methods to a combined super-resolution and conditional
high-wavenumber generation, we demonstrate turbulence recovery on a $8\times$
upsampling task, effectively doubling the range of recovered wavenumbers.

##  1 Introduction

Numerical approaches to fluid dynamics typically require a compromise between
computational accuracy and tractability. The range of length scales in
turbulence means that lower-fidelity approaches necessarily lose some
characteristics of a flow, while directly solving the governing equations
remains computationally infeasible in most cases. Developments in machine
learning to increase image resolution and recover missing details present us
with generative super-resolution methods, which may be used to recover small-
scale turbulent structures from fields produced by lower-fidelity methods.
However, despite efforts to capture all scales through super-resolution (SR),
small length-scale turbulent structures remain elusive.

Turbulence super-resolution considers the recovery of turbulent structures
from lower-resolution fields. Often in low-resolution fields, the sub-grid
scale stresses act to alter the resolved field, obscuring high-frequency
turbulence information and changing the trajectory of turbulence evolution. As
a result, the solution field is not simply a low-pass filtered version of the
high-fidelity field. This can make it difficult to infer useful information
regarding the impact of turbulence on the resolved fields.

Fukami et al. [1] established that non-generative convolutional methods can be
used to super-resolve turbulent flow fields, by exploiting the ability of
Convolutional Neural Networks (CNNs) to learn spatial correlations. Their
analysis of vorticity distributions and spectra in the reconstructed flows
showed that there are limitations to this approach, with many super-resolved
samples deviating substantially from the reference Direct Numerical Simulation
(DNS). This may be attributed to the fact that CNNs in SR produce blurred
images without sharp detail. Attempts to address this were made by Liu et al.
[2], by including a temporal component of the data in their super-resolution
method. Taking contiguous-in-time snapshots of turbulence as training samples
allows for a CNN to include learnt temporal correlations, and they found that
this greatly improved the physical accuracy of their predictions, and reduced
blurriness. Limitations of this work include poor performance in viscosity-
dominated regions.

The seminal work in super-resolution of turbulence using generative methods by
Kim et al. [3] showed that deep learning approaches can be powerful Super-
Resolution (SR) tools for turbulence. They highlighted the success of
generative methods in super-resolving data from LES data, rather than
downsampling high-fidelity data, using a form of Generative Adversarial
Network (GAN). It was mathematically shown by Drygala et al. [4] that GANs are
able to learn ergodic systems. Ergodic systems are those wherein a single
time-evolution of the system will eventually traverse all possible states. The
ergodicity hypothesis for turbulence is used frequently as justification for
the equivalency between long-in-time time averaging and ensemble averaging
approaches [5]. Drygala et al. [4] demonstrated a novel use of segmentation
masks with a conditional GAN to synthesise LES samples of flow around a stator
blade. This kind of conditioning information is useful in the context of
Computational Fluid Dynamics (CFD) because it may be exploited to reproduce
numerical boundary conditions and more accurately reproduce flows.

Diffusion models are a novel form of generative method, exploiting useful
properties of diffusion processes to generate samples of data [6]. They
utilise learnt neural denoising functions to parameterise stochastic processes
going from Gaussian noise to new samples of data. Diffusion models have the
potential to provide superior quality generation, relative to GANs, while also
avoiding several of the key challenges in training GANs such as unstable
training modes and mode collapse[7]. Diffusion models have demonstrated
superior performance compared to GANs for image synthesis [8], albeit with an
increased inference cost.

Inspired by recent developments in diffusion models using conditioning
information for generation, Shu et al. [9] developed a physics-informed
diffusion model for SR of turbulence. They demonstrated that incorporating
physics residuals in the conditioning information given to the diffusion model
during training can enhance the quality of generated samples as compared to a
baseline SR Denosing Diffusion Probabilistic Model (DDPM) [6]. Advances in
DDPM-based SR promise that this work can be extended to reduce inference cost
and increase generative accuracy [10].

This work aims to improve the statistical recovery of a turbulent flow field,
relative to the state of the art in the literature. Several derived quantities
including the vorticity field, vorticity Probability Density Function (PDF),
and the Turbulent Kinetic Energy (TKE) spectra are computed. These quantities
provide a statistical description of the flow field. The spectral information
is then used to define a cut-off for our second stage, high-wavenumber
turbulence recovery. Initial turbulence recovery is accomplished by a spatial
SR model [10], with a secondary recovery of the high-wavenumber structures,
using the generated super-resolved low-wavenumber structures as conditioning
information. We anticipate that this two-stage approach would allow for
turbulence recovery to arbitrary wavenumbers, rather than being confined to
perceptual accuracy. We test this method on a Kolmogorov flow [11], at an SR
factor of $8\times$, demonstrating statistical recovery of turbulence.

##  2 Methodology

Here we detail our approach to turbulence recovery on a statistically
stationary Kolmogorov flow. By integrating generative machine learning methods
with a novel approach to deriving conditioning information from turbulent flow
data, we aim to produce a two-stage generative model capable of generating
statistically accurate snapshots of turbulence.

###  2.1 Kolmogorov Flow Data

Training and validation data are obtained from different snapshots of the same
statistically stationary flow. The governing equations are the incompressible
Navier-Stokes equations in 2D:

$\displaystyle\dfrac{\partial u_{i}}{\partial t}+u_{j}\dfrac{\partial
u_{i}}{\partial x_{j}}$ $\displaystyle=-\dfrac{\partial p}{\partial
x_{i}}+\nu\dfrac{\partial^{2}u_{i}}{\partial x_{j}\partial x_{j}}+f_{i},$ (1)
$\displaystyle\dfrac{\partial u_{i}}{\partial x_{i}}$ $\displaystyle=0,$

where $u_{i}$ is the velocity field, $x_{i}$ is the distance measure, $p$ is
the pressure, $\nu$ is the kinematic viscosity,
$f_{i}=\sin{\left(10\delta_{i2}x_{2}\right)}$ is a steady sinusoidal forcing
term, and $\delta$ is the Dirac delta function. The domain is taken as a
square of length $2\pi$ in physical space, which for $256\times 256$ grid
points leads to a square of $128\times 128$ in wavenumber space. The
boundaries are fully periodic. We employ $\nu=0.0045\ m^{2}s^{-1}$ in our
simulations, allowing for turbulent dynamics. The equations are solved
numerically in the Fourier domain, using a spectral code [12]. The velocity
fields are initialised uniformly based on a prescribed peak wavenumber, and
are then filtered using white noise generated from a random seed to match a
defined spectral density. Data from the initial stages of turbulence evolution
is discarded so that the dataset contains only snapshots from the
statistically stationary portion of the flow; this range is determined by
computing the variation in time of the mean and variance of the velocity.

To ensure statistical independence of samples used during training and
validation, the autocorrelation function was used to define the decorrelation
period. Using this write frequency, we generated 5000 samples of decorrelated
training data. We reset the random seed for flow initialisation and then
generated a further 600 samples of decorrelated validation data (also
separated by the decorrelation period).

###  2.2 Diffusion Model

A diffusion model relies on learning the reverse process induced by a Markov
chain of Gaussian transitions which act to iteratively add noise to data,
transforming a distribution of data to a Gaussian. By learning the reverse
process, a diffusion model is able to generate samples of data from pure
noise. The forward noising schedule, $\beta$, is the variance of the Gaussian
transition kernel at each step in the forward process. We define
$\alpha=1-\beta$, and $\gamma$ as the cumulative product of $\alpha$. This can
be used to ‘jump’ forwards to a given noising step from $s=0$, and in effect
represents the information degradation in the noising process, starting at $1$
and reaching a maximum at $s=S$. Figure 1 presents two noising schedules, one
where large-scale information is destroyed quickly, and another where this
information is destroyed more gradually. The choice of noising schedule is a
hyperparameter; Chen [13] presents an in-depth discussion on noise scheduling
strategies, their impact on training, and on generation quality.

$s=0$$s=300$$s=600$$s=900$$\gamma$$\gamma$$s$$s$ Figure 1: A comparison of two
noising schedules in terms of their impact on a sample from the dataset, with
the last column showing the two $\gamma$ schedules. Top (linear):
$\beta_{0}=1\mathrm{e}{-4}$, $\beta_{S}=5\mathrm{e}{-2}$. Bottom (linear):
$\beta_{0}=1\mathrm{e}{-5}$, $\beta_{S}=1\mathrm{e}{-2}$. The $0$ subscript
denotes initial value, and $S$ is the final step in the variance schedule.

We use a DDPM [6] with the SR3 formulation [10] to super-resolve an average
pooled velocity field. A UNet [14] CNN is used as the backbone of our
diffusion model. During training, we show the diffusion model Low-Resolution
(LR) average-pooled DNS samples, and corresponding High-Resolution DNS (HR)
samples from a given instance of DNS for spatial super-resolution. High-
resolution samples are put through the forward noising process (Figure 1), and
concatenated to their counterpart low-resolution samples. This is fed through
the UNet, which is trained to predict the noise added to the HR sample while
also suitably conditioning on the low resolution information available. In
effect, the UNet is trained to be a denoising function.

Daras et al. [15] and Lai et al. [16] demonstrate that enforcing properties of
underlying stochastic processes can improve generative performance of
diffusion models. We observed that fine-tuning a trained model on a
consistency objective [15] drove the UNet towards an idealised denoising
function, and that relaxing some of the imposed constraints did not adversely
affect training or generation.

At inference time, the UNet is used as one component of an iterative scheme
for generation. Generation is carried out by taking a reverse noising
schedule, which takes samples of noise and iteratively traverses the
associated reverse Markov chain to generate a new sample from the original
data distribution, conditional on the low-resolution sample (i.e. super-
resolution). Equation 2 details the iterative scheme used during inference:

$\boldsymbol{y}_{s-1}\leftarrow\frac{1}{\sqrt{\alpha_{s}}}\left(\boldsymbol{y}_{s}-\frac{1-\alpha_{s}}{\sqrt{1-\gamma_{s}}}f_{\theta}\left(\boldsymbol{x},\boldsymbol{y}_{s},\gamma_{s}\right)\right)+\sqrt{1-\alpha_{s}}\boldsymbol{\epsilon}_{s},$
(2)

where $\boldsymbol{\epsilon_{s}}$ is an instantaneous sample of Gaussian
noise, $f_{\theta}(\boldsymbol{x},\boldsymbol{y}_{s},\gamma_{s})$ is the UNet
prediction of $\boldsymbol{\epsilon_{s}}$ (given the symbol
$\boldsymbol{\hat{\epsilon}}$), $s$ is used to denote denoising step, $\alpha$
is defined as before, and $\boldsymbol{y}_{s}$ is a sample of pure Gaussian
noise being iteratively transformed into a sample of data over $S$ steps,
starting from $\boldsymbol{y}_{S}$ and going to $\boldsymbol{y}_{0}$. While
$\boldsymbol{x}$ is used here for low-resolution, in general, it is a tensor
of conditioning information. We exploit this fact in our proposed second stage
generation, to be discussed. We note that SR3 removes the requirement that the
number of steps, $S$, must be the same for training and inference.

Saharia et al. [10] mentions the possibility of altering their original
regression target, $\epsilon$, to the denoised sample, $\hat{y}_{0}$. In our
experience, this regression target presented a practical issue: given a low-
resolution image, and a noisy high-resolution image, if the training objective
is to predict the original sample of data, the UNet will take the ‘easier’
optimisation trajectory and ignore the noisy high-resolution sample,
degenerating to a pure super-resolution CNN. What remains to be explored is
the use of the $\hat{y}_{0}$ regression target in unconditional generation,
where a low-resolution sample is not present. In this work, we use the
$\epsilon$ regression target.

###  2.3 Fourier Filtering

Fourier transforms allow for analysis of turbulence in wavenumber space. We
consider only discrete Fourier transforms, computed using Fast Fourier
Transforms (FFT). The maximum wavenumber is the Nyquist wavenumber, defined as
$k_{max}=\nicefrac{{\pi}}{{L}}N$ for N uniformly spaced grid points along a
given axis [17]. Here, as $L=2\pi$, $k_{max}=\nicefrac{{1}}{{2}}N$. The
discrete 2D FFT is given in Eq. 3, and the wavenumber is the magnitude of the
wavevector (Eq. 4):

$\mathcal{F}\left(\mathcal{F}\left(u_{x,y}\right)_{x}\right)_{y}=\sum^{N_{y}-1}_{m=0}\sum^{N_{x}-1}_{j=0}u_{x,y}e^{-2\pi\text{i}\left(\nicefrac{{j}}{{N_{x}}}+\nicefrac{{m}}{{N_{y}}}\right)}$
(3) $\displaystyle
k=\lvert\boldsymbol{\kappa}\rvert=\begin{vmatrix}\kappa_{x}\\\ \kappa_{y}\\\
\end{vmatrix}\quad\text{for
}-\frac{1}{2}N_{x}\leq\kappa_{x}\leq\frac{1}{2}N_{x},$ (4)
$\displaystyle\quad\text{for
}-\frac{1}{2}N_{y}\leq\kappa_{y}\leq\frac{1}{2}N_{y},$

where $N_{i}$ is the number of grid points in each spatial direction [17], and
$u_{x,y}$ is used to denote separate treatment of the longitudinal and
transverse velocity components. We select a circular filter in wavenumber
space with radius equal to the wavenumber limit that is resolved by the first-
pass SR. Herein, we choose (empirically) $k=35$.

Figure 2: Spectral filters applied to a given 2D sample of the Kolmogorov
flow, at $k\leq 35$ and $k>35$. The field shown here is
$\log{(\lvert\mathrm{FFT}_{x,y}\left(u_{x}\right)\rvert)}$, which is the log
magnitude of the 2D FFT amplitude.

Figure 2 shows a given sample of turbulent flow passed through a low-pass
filter and high-pass filter at $k=35$ in wavenumber space. These samples are
then transformed back to physical space using a 2D inverse FFT (Figure 3). We
include additional filtering to highlight the relative orders of magnitude
between wavenumber ranges. We hypothesise that this may contribute to
difficulties encountered in capturing higher-frequency components in super-
resolved turbulence [1, 3, 18]; p-norm based loss functions in ML approach
converge on orders of magnitude significantly lower than the amplitude of
these wavenumbers in physical space, which makes recovery of information
beyond this difficult.

Figure 3: $u_{x}$, passed through spectral filters: $k\leq 64$ (left), $k>64$
(center), $k>96$ (right). We note the changing magnitude of each field,
illustrating the numerical difficulty in capturing these components. Colour
bars for the High-Pass Filtered (HPF) samples are scaled to better illustrate
dominant fluctuations.

Fourier-filtering provides a new dataset used for training the stage two
model, i.e., the spectral filtered diffusion model. During training, the model
is shown the velocity fields passed through a Low-Pass Filter (LPF), and High-
Pass Filter (HPF), and trained to predict noise content in high-frequency
fields conditioned on low-frequency information. In a similar approach to that
outlined above, given pure Gaussian noise and a low-frequency field obtained
by filtering the first stage super-resolution, the model is then able to
generate new samples of high-frequency complement information conditional on
the generated low-frequency fields.

The full dataset preparation, training, and inference process is detailed in
Figure 4.

Figure 4: Procedure for spectrally decomposed turbulence generation. In stage
1, DNS data is downsampled to produce pairs of low and high resolution samples
$(x,y)$. A DDPM, $f_{\theta}$ is trained to predict Gaussian noise in noisy
high-resolution samples, $y_{s}$, conditioned on the low-resolution sample
$x$, and the noise level $\gamma_{s}$. The trained DDPM is then used in
inference to upsample new snapshots of turbulent flow. TKE spectra of the
generated samples are compared against those of the DNS, giving a ‘cutoff’
wavenumber, $k_{filter}$. In stage 2, $k_{filter}$ is used to filter the DNS
in wavenumber space to obtain pairs of low and high pass filtered velocity
fields, $(x^{\prime},y^{\prime})$. These are then used to train a second DDPM,
$f_{\theta}^{\prime}$. This may then be used in inference to obtain a
generated high-pass filtered field, conditional on the low-pass filtered field
from stage 1 generation. TKE spectra indicate that stage 2 allows for accurate
generation of higher-wavenumber turbulent structures than the stage 1 method
allows for alone.

##  3 Results

###  3.1 Spatial Super-Resolution of a Kolmogorov Flow

Here we present the results of a spatial super-resolution diffusion model
trained to learn the distribution of high-resolution fields, $u_{i}$, given
low-resolution representations of the fields. We train a DDPM (specifically
SR3 [10]) to reconstruct a $256\times 256$ field from a $32\times 32$ low-
resolution sample obtained by average-pooling the DNS solution. We examine a
variety of quantitative and qualitative metrics to determine the extent to
which turbulence has been recovered in our approach, on a validation dataset.

The vorticity, $\boldsymbol{\omega}=\nabla\times\mathbf{u}$, is computed using
an 8th order finite differencing in physical space for the high-resolution and
a 2nd order approximation for the low-resolution. We should anticipate an
approximately symmetric distribution of vorticity centred at 0 for individual
samples.

$LR$$SR$$HR$ Figure 5: Contours of
$\boldsymbol{\omega}^{*}=\dfrac{\boldsymbol{\omega}}{\boldsymbol{\omega}_{max}}$
for the first stage spatial super-resolution, for three representative
samples. The $32\times 32$ [left] is super-resolved using a diffusion model to
$256\times 256$ [middle], which we compare to the ground truth DNS field
[right].

From Figure 5, we observe that after the first stage of super-resolution, on
an $8\times$ upsampling task from $32\times 32$ to $256\times 256$ points, the
flow structures are recovered well. The characteristic interactions between
positive and negative vortices are also captured well, with clockwise and
counterclockwise rotating structures. We note that the aim in generative
super-resolution is not to produce a like-for-like version of the high-
resolution sample, but to learn an underlying statistical description of the
high-resolution data. To this end, some perceptual difference is acceptable,
provided the generated and ground truth samples are statistically similar.
Visible in the figure is the presence of some slight noise, which is likely to
be a byproduct of the diffusion process. Our preliminary findings indicate
that this can be mitigated through more extensive hyperparameter tuning.

The treatment of flow variables as continuous random variables implies that
they are completely characterised by their PDF – rather than deterministically
attempting to predict the value at a timestep, it is more sensible to consider
the likelihood of a variable taking a certain value. We show the PDF of
vorticity in Figure 6, presented on a log scale to better highlight values at
the extreme ends of the scale. We observe that the super-resolved data shows
good agreement with the high resolution data. This demonstrates the super-
resolved fields are statistically similar to the ground truth DNS.

Figure 6: $\mathrm{log}_{10}\left(P\left(\boldsymbol{\omega}\right)\right)$
for the first stage spatial super-resolution, for a representative sample.
$LR$ is $32\times 32$, $HR$ is the $256\times 256$ DNS, and $SR$ is from the
super-resolved fields.

In order to investigate the recovery of information at all length scales of
turbulence, we must examine the turbulent kinetic energy spectra. Figure 7
shows that through a learnt $8\times$ upsampling, the spatial SR diffusion
model is able to recover wavenumbers in the range $16<k\leq 35$, after which
the SR solution diverges, as we would expect from the literature. Results from
[9] indicate diffusion-based recovery to higher wavenumbers than this, but we
could not reproduce their work on our fully decorrelated dataset; the authors
omitted a detailed discussion on the level of correlation between their
training and validation sets. The recovered wavenumber limit is shown with a
grey dashed line. The missing information beyond $k=35$ may be explained by
the numerical limitations in learning information at the high wavenumbers
(§2.3), and limited model capacity (due to training limitations).

Figure 7: TKE Spectra from the single-stage super-resolution. $LR$ is
$32\times 32$, $HR$ is the $256\times 256$ DNS, and $SR$ is from the super-
resolved fields.

###  3.2 Fourier-Filtered Turbulence Generation

It is evident that the high wavenumber turbulent structures are difficult to
capture due to their small contribution to the flow structure, notwithstanding
their significant contribution to the flow statistics. Both perceptually and
from the probability distribution, it seems that turbulence recovery up to
$k=35$ appears to be sufficient for reasonable first order statistics.
However, spectral analysis has shown that there is still non-negligible energy
within these high wavenumbers, and for the purposes of scale-resolving
simulations, these wavenumbers are considered significant. Here we demonstrate
that using information from the spectrum of the spatially super-resolved flow,
a second stage of turbulence recovery can be executed using a diffusion model
trained to generate high-wavenumber flow components conditioned on their low-
wavenumber complement.

Figure 8: Representative sample of $u_{x}$ with $k\leq 35$ (left), and $k>35$
(right), prior to standardisation.

From Figure 7, we identify the line at $k=35$ as the wavenumber at which the
super-resolved field starts to diverge from the reference DNS solution. The
recovery up to this wavenumber is strong. As such, we take a spectral filter
(Figure 2) and apply it to the 2D FFT of the velocity field, i.e., the
velocity field in wavenumber space. We then convert the fields back to
physical space, obtaining low-wavenumber, high-wavenumber pairs as in Figure
8. The conversion back to physical space is required as the generative model
is not guaranteed to produce real (i.e. non-complex) fields if generating in
wavenumber space. A key feature of this form of filtering operation is that
the sum of the low-wavenumber and high-wavenumber field in physical space is
equal to the ground truth DNS field; this is exploited in order to use this
approach for high-wavenumber correction of the spatial super-resolution.

Figure 9: $u_{x}\left(k\leq 35\right)_{\mathrm{GEN}}$ [left],
$u_{x}\left(k>35\right)_{\mathrm{DNS}}$ [middle],
$u_{x}\left(k>35\right)_{GEN}$ [right] at three representative timesteps.
$GEN$ is used for generated fields from the first and second stage diffusion
models. Middle and right columns show fields that are centre-cropped for
clarity – largest values occur nearer the boundaries and obscure main-field
oscillations. The crop location is indicated on the low-wavenumber fields in
the left column by the red dashed line, which corresponds to the boundary in
the middle and right column.

The high-wavenumber flow fields are presented in Figure 9. The generated high-
wavenumber fields show strong agreement with the ground truth DNS high-
wavenumber fields. This lends credence to the conjecture that high-wavenumber
recovery using diffusion models is made possible by isolating and rescaling
high-wavenumber information. As before, we analyse spectral information to
ascertain the turbulence recovery in wavenumber regions of interest, as in
Figure 10.

Figure 10: TKE spectra from high-wavenumber conditional turbulence generation.
The sum of low and high wavenumber components of the reconstructed flow is
compared to the DNS field.

The red dashed line indicated on figure 10 shows the TKE spectrum for the
high-wavenumber component of the DNS flow. We demonstrate that our spectral
decomposition diffusion model is able to recover turbulence information in
this region up to $~{}k=74$, which means that through the first and second
stage of turbulence generation, our method recovers a reasonable portion of
the wavenumbers simulated in the DNS. We anticipate that a general N-stage
model would iteratively be able to recover the whole spectrum, but leave this
exercise as future work. The number of stages, N, may be considered a
hyperparameter which in this study we fix to 2.

##  4 Conclusions, Considerations, and Future Work

We have demonstrated that a diffusion model may be used as a generative
technique to recover high-fidelity information lost from a high resolution
field. We extend approaches to do so by using spectral filters in wavenumber
space to decompose flow fields into high and low wavenumber components,
training a diffusion model to learn the conditional probability of a high-
frequency field given a low-frequency field. We investigate the performance of
our method by considering physical quantities recovered in the super-resolved
flow. We find that diffusion models are a powerful generative method for
super-resolution of turbulence, and that strong statistical recovery of
turbulence can be achieved by the developed method.

We have omitted a discussion on inference cost in diffusion models, but a key
open issue in this area is the fact that as compared to other generative
methods which require (typically) a single network evaluation through their
parameterising network, the iterative nature of diffusion models necessitates
multiple network evaluations. Denoising Diffusion Implicit Models (DDIM) aim
to address this by driving down the number of network evaluations through a
novel sampling approach [19]. Additionally, we note that our two-stage
turbulence recovery approach is equally applicable to other generative
methods, such as GANs.

Additionally, there has been substantial work on exploring the impact of
noising schedules. We ran a simple grid search over the reverse schedule to
determine the ideal reverse variance schedule for generation, but due to
resource constraints we did not consider multiple forward schedules. There is
evidence to suggest that the noising schedule has a significant impact on the
generative capabilities of a diffusion model, and warrants further examination
[13].

A limitation of this approach to filtering in wavenumber space for a second
stage of turbulence recovery is that the filter is dependent on the
wavenumbers recovered in the first stage super-resolution. This has a direct
impact on training time; the first and second stage diffusion models cannot be
trained in parallel and must be trained sequentially after testing the
performance of the first stage spatial super-resolution model. We propose that
our method may be extended by using a reverse process designed to recover
specific wavenumbers, which may be known a priori and thus allowing for the
second stage high-wavenumber diffusion model to be trained in parallel. This
would also enable the use of variable wavenumber cutoffs for regions where the
flow is resolved well vs regions where it is less well resolved.

We propose that this method could be extended to investigate specified ranges
of wavenumber space. Spherical shells or doughnut shaped filters in 3D and 2D
respectively allow for the decomposition of a flow into its constituent
wavenumber modes. We believe that recursively applying corrections at
different wavenumber ranges may be a viable option for subgrid-scale modelling
using lower-fidelity CFD methods, where the maximum simulated wavenumber is
less than the maximum wavenumber for a DNS-like solution.

##  5 Acknowledgements

The authors would like to acknowledge the assistance given by Research IT and
the use of the Computational Shared Facility at The University of Manchester.
The authors would also like to personally thank Daniel Kelshaw at Imperial
College London for fruitful conversations regarding spectral decomposition. SD
acknowledges a Dame Kathleen Ollerenshaw Fellowship.

## References

  * Fukami et al. [2019] Kai Fukami, Koji Fukagata, and Kunihiko Taira.  Super-resolution reconstruction of turbulent flows with machine learning.  _Journal of Fluid Mechanics_ , 870:106–120, July 2019.  ISSN 0022-1120, 1469-7645.  doi: 10.1017/jfm.2019.238.
  * Liu et al. [2020] Bo Liu, Jiupeng Tang, Haibo Huang, and Xi-Yun Lu.  Deep learning methods for super-resolution reconstruction of turbulent flows.  _Physics of Fluids_ , 32(2):025105, February 2020\.  ISSN 1070-6631.  doi: 10.1063/1.5140772.
  * Kim et al. [2021] Hyojin Kim, Junhyuk Kim, Sungjin Won, and Changhoon Lee.  Unsupervised deep learning for super-resolution reconstruction of turbulence.  _Journal of Fluid Mechanics_ , 910:A29, March 2021.  ISSN 0022-1120, 1469-7645.  doi: 10.1017/jfm.2020.1028.
  * Drygala et al. [2022] Claudia Drygala, Benjamin Winhart, Francesca di Mare, and Hanno Gottschalk.  Generative Modeling of Turbulence.  _Physics of Fluids_ , 34(3):035114, March 2022\.  ISSN 1070-6631, 1089-7666.  doi: 10.1063/5.0082562.
  * Galanti and Tsinober [2004] B. Galanti and A. Tsinober.  Is turbulence ergodic?  _Physics Letters A_ , 330(3-4):173–180, September 2004.  ISSN 03759601.  doi: 10.1016/j.physleta.2004.07.009.
  * Ho et al. [2020] Jonathan Ho, Ajay Jain, and Pieter Abbeel.  Denoising Diffusion Probabilistic Models, December 2020.
  * Xiao et al. [2022] Zhisheng Xiao, Karsten Kreis, and Arash Vahdat.  Tackling the Generative Learning Trilemma with Denoising Diffusion GANs, April 2022.
  * Dhariwal and Nichol [2021] Prafulla Dhariwal and Alex Nichol.  Diffusion Models Beat GANs on Image Synthesis, June 2021.
  * Shu et al. [2023] Dule Shu, Zijie Li, and Amir Barati Farimani.  A physics-informed diffusion model for high-fidelity flow field reconstruction.  _Journal of Computational Physics_ , 478:111972, April 2023\.  ISSN 00219991.  doi: 10.1016/j.jcp.2023.111972.
  * Saharia et al. [2021] Chitwan Saharia, Jonathan Ho, William Chan, Tim Salimans, David J. Fleet, and Mohammad Norouzi.  Image Super-Resolution via Iterative Refinement, June 2021.
  * Platt et al. [1991] N. Platt, L. Sirovich, and N. Fitzmaurice.  An investigation of chaotic Kolmogorov flows.  _Physics of Fluids A: Fluid Dynamics_ , 3(4):681–696, April 1991.  ISSN 0899-8213.  doi: 10.1063/1.858074.  URL https://pubs.aip.org/pof/article/3/4/681/402184/An-investigation-of-chaotic-Kolmogorov-flows.
  * Dresdner et al. [2022] Gideon Dresdner, Dmitrii Kochkov, Peter Norgaard, Leonardo Zepeda-Núñez, Jamie A. Smith, Michael P. Brenner, and Stephan Hoyer.  Learning to correct spectral methods for simulating turbulent flows.  2022\.  doi: 10.48550/ARXIV.2207.00556.  URL https://arxiv.org/abs/2207.00556.
  * Chen [2023] Ting Chen.  On the Importance of Noise Scheduling for Diffusion Models, May 2023.
  * Ronneberger et al. [2015] Olaf Ronneberger, Philipp Fischer, and Thomas Brox.  U-Net: Convolutional Networks for Biomedical Image Segmentation, May 2015.
  * Daras et al. [2023] Giannis Daras, Yuval Dagan, Alexandros G. Dimakis, and Constantinos Daskalakis.  Consistent Diffusion Models: Mitigating Sampling Drift by Learning to be Consistent, February 2023.  URL http://arxiv.org/abs/2302.09057.  arXiv:2302.09057 [cs, math].
  * Lai et al. [2023] Chieh-Hsin Lai, Yuhta Takida, Naoki Murata, Toshimitsu Uesaka, Yuki Mitsufuji, and Stefano Ermon.  FP-Diffusion: Improving Score-based Diffusion Models by Enforcing the Underlying Score Fokker-Planck Equation, June 2023.  URL http://arxiv.org/abs/2210.04296.  arXiv:2210.04296 [cs].
  * Pope [2000] Stephen B. Pope.  _Turbulent Flows_.  Cambridge University Press, 2000.  doi: 10.1017/CBO9780511840531.
  * Kelshaw et al. [2022] Daniel Kelshaw, Georgios Rigas, and Luca Magri.  Physics-Informed CNNs for Super-Resolution of Sparse Observations on Dynamical Systems, November 2022.
  * Song et al. [2022] Jiaming Song, Chenlin Meng, and Stefano Ermon.  Denoising Diffusion Implicit Models, October 2022.