From c3b3d33e6f096f28a474b9f90a41c2dfdd527fca Mon Sep 17 00:00:00 2001 From: Kun Chen Date: Sat, 10 Feb 2024 23:06:02 +0800 Subject: [PATCH] improve readme --- README.md | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 7fbd1baf..7c18c56a 100644 --- a/README.md +++ b/README.md @@ -20,19 +20,16 @@ In general, Feynman diagrams represents high-order integral. The integrand are propagators/interactions composed by the basis arithmetic operations (multiplication, addition, power, etc). The sequence of calculating the integrand by combining the propagators/interactions with the arithmetic operatos can be represented as an algebraic computational graph. In this sense, the computational graph serves as an intermediate representation that standardizes the treatment of various diagram types, ensuring a consistent approach across different QFT calculations. ![infrastructure](assets/diagram_compiler.svg?raw=true "Compiler Infrastructure") +Drawing from these insights, the architecture of our compiler is intentionally crafted to process Feynman diagrams via a strategic, three-stage process that reflects the advanced design principles of the LLVM compiler architecture. This approach enhances the compiler's flexibility for a wide array of QFT computations and significantly improves its computational efficiency. The workflow is organized into three critical stages: -Based on these insights, the compiler's architecture is designed to process Feynman diagrams via a structured, three-stage procedure, mirroring the design principles of the advanced LLVM compiler architecture. This strategy not only broadens the compiler's versatility for diverse QFT computations but also markedly enhances its computational efficiency. The procedure unfolds in three distinct stages: +- **Front End**: In this initial phase, Feynman diagrams are generated and transformed into a standardized intermediate representation, taking the form of static computational graphs. This stage features two key algorithms for generating generic Feynman diagrams for weak-coupling expansions: + - `Parquet` module systematically organizes higher-order Feynman diagrams into a concise hierarchical structure of sub-diagrams, enabling efficient evaluation of repeated sub-diagrams. This module introduces algorithms for constructing streamlined computational graphs for two-, three-, and four-point vertex functions by exploiting the perturbative representations of the Dyson-Schwinger and parquet equations. This approach facilitates the analysis of a wide array of observables in quantum many-body problems. + - `GV` module, specifically aimed at many-electron problems with Coulomb interactions, incorporates the algorithm proposed in [Nat Commun 10, 3725 (2019)](https://doi.org/10.1038/s41467-019-11708-6). + - The front end also allows for the integration of new diagram types by users, enhancing its adaptability. -- **Front End**: This initial phase generates Feynman diagrams and converts them into a unified intermediate representation, shaping them as static computational graphs. The current implementation includes two diagram-generated types: `GV` and `Parquet`. - - `GV` module is used to generate Feynman diagrams, which are regrouped into a -much smaller number of sign-blessed groups to boost the computational efficiency. The grouping is achieved by leveraging the fermionic crossing symmetry and the free-energy generating functional. Details see [Nat Commun 10, 3725 (2019)](https://doi.org/10.1038/s41467-019-11708-6). - - `Parquet` module is used to build the 4-point vertex function from a bottom-up approach using the parquet equations and generate other Feynman diagrams coupling with the Dyson-Schwinger equations. - - -Users can also incorporate new diagram types by extending the front end. +- **Intermediate Representation**: At this stage, the compiler applies optimizations and Automatic Differentiation (AD) to the static computational graph. This process is geared towards refining the graph for thorough analysis and optimization. The optimizations are aimed at streamlining the graph by removing redundant elements, flattening nested chains, and eliminating zero-valued nodes, among other strategies. The incorporation of Taylor-mode AD is critical for efficiently calculating high-order derivatives, essential for deriving diagrams for specific heat, RG flow equations, or renormalized Feynman diagrams. -- **Intermediate Representation**: At this stage, the compiler applies optimizations and AD to the static computational graph, facilitating thorough analysis and refinement. The optimizations aim to streamline the graph by eliminating redundant elements, flattening nested chains, and removing zero-valued nodes, among other enhancements. The Taylor-mode AD --- an algorithm for efficient high-order derivatives calculations --- is crucial for deriving specific heat diagrams, RG flow equations, or renormalized Feynman diagrams. - -- **Back End**: The final phase focuses on converting the optimized graph into executable code, compatible with a wide range of computing environments. This stage supports various programming languages and ensures seamless integration with different software and hardware ecosystems, thereby extending the compiler's utility across multiple platforms. +- **Back End**: This final phase is responsible for translating the optimized graph into executable code that is compatible with a broad spectrum of computing environments. It supports various programming languages and facilitates seamless integration with different software and hardware ecosystems, significantly extending the compiler's utility across multiple platforms. ## Usage