Fixing sign conventions and translations between Packages

Author: satfra

examples/FlowingReparametrisation.nb

@@ -560,22 +560,14 @@
             $ProfileTermsEqualSuccess++;
             Return @ FTerm[2, t1]
         ];
-        If[Length[t1] >= 2 && Length[t2] >= 2,
-            If[t1[[2 ;; ]] === t2[[2 ;; ]] && FreeQ[{t1[[1]]}, Alternatives @@ $indexedObjects, Infinity],
-                $ProfileTermsEqual += AbsoluteTime[] - $profT0;
-                $ProfileTermsEqualSuccess++;
-                Return @ FTerm[t1[[1]] + t2[[1]], t1[[2 ;; ]]]
-            ];
-            If[t1[[2 ;; ]] === t2[[1 ;; ]] && FreeQ[{t1[[1]]}, Alternatives @@ $indexedObjects, Infinity],
-                $ProfileTermsEqual += AbsoluteTime[] - $profT0;
-                $ProfileTermsEqualSuccess++;
-                Return @ FTerm[t1[[1]] + 1, t1[[2 ;; ]]]
-            ];
-            If[t1[[1 ;; ]] === t2[[2 ;; ]] && FreeQ[{t1[[1]]}, Alternatives @@ $indexedObjects, Infinity],
-                $ProfileTermsEqual += AbsoluteTime[] - $profT0;
-                $ProfileTermsEqualSuccess++;
-                Return @ FTerm[1 + t2[[1]], t1[[1 ;; ]]]
-            ];
+        {fac1, terms1} = SplitPrefactor[setup, t1];
+        {fac2, terms2} = SplitPrefactor[setup, t2];
+        If[terms1 === terms2,
+            factor = fac1 + fac2;
+            $ProfileTermsEqual += AbsoluteTime[] - $profT0;
+            $ProfileTermsEqualSuccess++;
+            If[factor === 0, Return[FTerm[0]]];
+            Return[FTerm[factor, terms1]]
         ];
         (* Use pre-computed data *)
         cidxt1 = data1["cidx"];

examples/Yang-Mills.nb

@@ -43,7 +43,7 @@
             Abort[]
         ];
         indices = GetClosedSuperIndices[setup, ret];
-        newIndices = Map[Symbol @ SymbolName @ Unique[StringReplace[ToString[#], i : DigitCharacter.. :> ""]]&, indices];
+        newIndices = Map[Symbol @ SymbolName @ Unique["ci"]&, indices];
         replacements = Thread[indices -> newIndices];
         If[ValueQ[$FixIndicesTime], $FixIndicesTime += AbsoluteTime[] - t0; $FixIndicesCount++];
         Return[ret /. replacements];

modules/AnSEL/Simplify.m

@@ -62,10 +62,16 @@
     ];
 
 QMeSForm[setup_, expr_] :=
-    (AssertFSetup[setup]; Map[QMeSNaming[setup, #]&, expr, {1, 3}] //. {FEx :> List, FTerm :> Times});
+    (
+        AssertFSetup[setup];
+        Map[QMeSNaming[setup, #]&, expr, {1, 3}] //. {FEx :> List, FTerm :> Times}
+    );
 
 QMeSForm[setup_, expr_Association] :=
-    (AssertFSetup[setup]; AssociationMap[QMeSForm[setup, #]&, expr]);
+    (
+        AssertFSetup[setup];
+        AssociationMap[QMeSForm[setup, #]&, expr]
+    );
 
 (* Transforming QMeS to FunKit *)
 
@@ -96,13 +102,13 @@
         newa =
             newa //.
                 {
-                    <|"type" -> "Regulatordot", "indices" -> {a__}|> :> makeObj[Rdot, {a}[[All, 1]], {a}[[All, 2, 1]]]
+                    <|"type" -> "Regulatordot", "indices" -> {a__}|> :> makeObj[Rdot, {a}[[All, 1]], -{a}[[All, 2, 1]]]
                     ,(**)
                     <|"type" -> "Propagator", "indices" -> {a__}|> :> makeObj[Propagator, {a}[[All, 1]], {a}[[All, 2, 1]]]
                     ,(**)
-                    assoc_Association /; assoc["type"] === "nPoint" && assoc["spec"] === "classical" :> makeObj[S, assoc["indices"][[All, 1]], -assoc["indices"][[All, 2, 1]]]
+                    <|"type" -> "nPoint", "indices" -> {a__}, "nPoint" -> _, "spec" -> "classical"|> :> makeObj[S, {a}[[All, 1]], -{a}[[All, 2, 1]]]
                     ,(**)
-                    <|"type" -> "nPoint", "indices" -> {a__}, __|> :> makeObj[GammaN, {a}[[All, 1]], {a}[[All, 2, 1]]]
+                    <|"type" -> "nPoint", "indices" -> {a__}, "nPoint" -> _, "spec" -> "none"|> :> makeObj[GammaN, {a}[[All, 1]], -{a}[[All, 2, 1]]]
                 };
         Return[FTerm[pref, ##]& @@ newa]
     ];
@@ -154,4 +160,7 @@
 DoFunForm::notImplemented = "DoFunForm is not yet implemented.";
 
 DoFunForm[args___] :=
-    (Message[DoFunForm::notImplemented]; Abort[]);
+    (
+        Message[DoFunForm::notImplemented];
+        Abort[]
+    );

modules/FEDeriK/Cleaning.m

@@ -120,7 +120,7 @@
 FMakeClassicalAction[] /; Head[$GlobalSetup] =!= Symbol :=
     FMakeClassicalAction[$GlobalSetup];
 
-FMakeClassicalAction[] :=
+FMakeClassicalAction[] /; Head[$GlobalSetup] === Symbol :=
     (
         Message[FunKit::noGlobalSetup];
         Abort[]

modules/FEDeriK/Compatibility.m

@@ -22,17 +22,21 @@
             Message[FMakeClassicalAction::noTruncation];
             Abort[]
         ];
-        FEx @@
-            Map[
-                (
-                    prefac = Split[#];
-                    prefac = Times @@ (1 / ((Length[#]& /@ prefac)!));
-                    indices = Map[Unique["i"]&, #];
-                    FTerm[prefac, makeObj[S, #, -indices]] ** (FTerm @@ Table[#[[i]][indices[[i]]], {i, 1, Length[#]}])
-                )&
-                ,
-                OrderFieldList[setup, #]& /@ setup["Truncation"][S]
-            ]
+        FOrderFields[
+            setup
+            ,
+            FEx @@
+                Map[
+                    (
+                        prefac = Split[#];
+                        prefac = Times @@ (1 / ((Length[#]& /@ prefac)!));
+                        indices = Map[Unique["i"]&, #];
+                        FTerm[prefac, makeObj[S, Reverse @ #, -Reverse @ indices]] ** (FTerm @@ Table[#[[i]][indices[[i]]], {i, 1, Length[#]}])
+                    )&
+                    ,
+                    OrderFieldList[setup, #]& /@ setup["Truncation"][S]
+                ]
+        ]
     ];
 
 (**********************************************************************************
@@ -91,11 +95,13 @@
             ReduceIndices[setup, #]&;
         (*Separate powers out into factors in the FTerm. Need this to insert FDOp in the next step*)
         dS = dS //. Times[pre___, f1_[id1_], post___] :> NonCommutativeMultiply[pre, f1[id1], post];
-        (*Insert \[Phi]^a->\[CapitalPhi]^a+G^ab\[Delta]/\[Delta]\[CapitalPhi]^b
-          Use Replace at level {2} (FTerm arguments) to avoid replacing field[index]
-          patterns inside indexed objects in NotationB.*)
+(*Insert \[Phi]^a->\[CapitalPhi]^a+G^ab\[Delta]/\[Delta]\[CapitalPhi]^b
+  Use Replace at level {2} (FTerm arguments) to avoid replacing field[index]
+  patterns inside indexed objects in NotationB.*)
         dS =
-            Replace[dS,
+            Replace[
+                dS
+                ,
                 Map[
                     #[id_] :>
                         Module[{i},
@@ -104,13 +110,15 @@
                         ]&
                     ,
                     GetAllFields[setup]
-                ],
+                ]
+                ,
                 {2}
             ];
         dS //
         FResolveDerivatives[setup, #]& //
         If[ModuleLoaded[AnSEL] && $AutoSimplify === True,
-            FunKit`FSimplify[setup, #],
+            FunKit`FSimplify[setup, #]
+            ,
             #
         ]&
     ];

modules/FEDeriK/Global.m

@@ -875,6 +875,8 @@ Collect concrete fields from ALL indices (not just closed), since
         Return[ret0];
     ];
 
+$TruncationAlgorithm = CTrunc;
+
 FTruncate[setup_, expr_FEx] :=
     Module[{ret0, ret1, ret2, ret3, annotations},
         AssertFSetup[setup];
@@ -894,7 +896,7 @@ Collect concrete fields from ALL indices (not just closed), since
         {ret0, annotations} = SeparateFExAnnotations[expr];
         (*Take care of closed indices — CTrunc returns lists-of-lists*)
         Module[{t0 = AbsoluteTime[]},
-            ret0 = BalancedMap[LTrunc[setup, #]&, ret0];
+            ret0 = BalancedMap[$TruncationAlgorithm[setup, #]&, ret0];
 (*Merge: ret0 is a List where each element is a list-of-bare-lists from LTrunc.
   Flatten one level, filter empties/zeros, wrap each bare list in FTerm.*)
             ret0 =

modules/FEDeriK/MasterEquations.m

@@ -261,7 +261,9 @@
         If[FileExistsQ[Directory[] <> "/form.set"],
             Return[]
         ];
-        session = StartExternalSession[{"Python", "Evaluator" -> <|"Dependencies" -> {"formtools-formset"}, "EnvironmentName" -> "FunKit"|>}];
-        ExternalEvaluate[session, {"import formset", "formset.main(['-o','" <> Directory[] <> "/form.set" <> "','-p','100'])"}];
-        DeleteObject[session];
+        If[$VersionNumber >= 14.1,
+            session = StartExternalSession[{"Python", "Evaluator" -> <|"Dependencies" -> {"formtools-formset"}, "EnvironmentName" -> "FunKit"|>}];
+            ExternalEvaluate[session, {"import formset", "formset.main(['-o','" <> Directory[] <> "/form.set" <> "','-p','100'])"}];
+            DeleteObject[session];
+        ];
     ];

modules/FEDeriK/Truncation.m

@@ -760,7 +760,27 @@ \subsection{Deriving diagrams}
 In the above, $(-1)^{ab}$ is the fermionic minus sign as defined in \labelcref{eq:fminus}, represented in \FunKit as \mmaInlineCell{Input}{\mmaDef{FMinus}[\{\mmaDef{AnyField},\mmaDef{AnyField}\},\{a,b\}]}. Note additionally that, $\gamma_{ab}$ is represented as \mmaInlineCell{Input}{\mmaDef{\(\pmb{\gamma}\)}[\{\mmaDef{AnyField},\mmaDef{AnyField}\},\{-a,-b\}]}, see also \Cref{tab:notation} for an overview of the notation.
 
 \FunKit has automatically simplified the diagrams resulting from the above derivation. For finer control, the functions \mathem{\mmaDef{FResolveFDOp}} and \mathem{\mmaDef{FSimplify}} allow resolving derivatives and simplifying expressions step by step. In general, however, we recommend using \mathem{\mmaDef{FTakeDerivatives}}, as it provides the most automated workflow and generates additional simplification hints such as symmetry properties of the derivatives.
-We describe the simplification and derivative algorithm used by \FunKit in more detail in the green boxes below.
+We describe the simplification and derivative algorithms used by \FunKit in more detail in the green boxes below.
+
+
+\begin{tcolorbox}[title=Algorithm details: Diagram simplification,
+	title filled=false,
+	colback=pastelgreen!5!white,
+	colframe=pastelgreen!73!black,
+	fonttitle=\bfseries]
+	
+	With \mathem{\mmaDef{FSimplify}} we introduce an algorithm for the simplification of large sums of diagrams. \mathem{\mmaDef{FSimplify}} can detect identical diagrams and performs the following steps to find all matches and sum them:
+	%
+	\begin{enumerate}
+		\item All Diagrams with exactly the same content of objects and the same set of open indices are grouped together.
+		\item Each group is then processed in parallel: Pairs of diagrams are sequentially built and compared.
+		\item The comparison of two diagrams is performed by traversing the graphs of both at the same time and checking for identity.
+		\item If symmetries of open indices are provided, all permutations (with possible prefactors, e.g. minus signs for fermionic permutations) are also explored.
+		\item If the graphs are identical, they are merged. When merging, the second diagram is prepended with a factor containing all signs needed to give it precisely the same index ordering and structure as the first diagram.
+	\end{enumerate}
+	
+\end{tcolorbox}
+
 
 \begin{tcolorbox}[title=Algorithm details: Derivatives,
 	title filled=false,
@@ -789,29 +809,6 @@ \subsection{Deriving diagrams}
 	
 \end{tcolorbox}
 
-\vfill 
-
-\newpage
-
-
-\begin{tcolorbox}[title=Algorithm details: Diagram simplification,
-	title filled=false,
-	colback=pastelgreen!5!white,
-	colframe=pastelgreen!73!black,
-	fonttitle=\bfseries]
-
-	With \mathem{\mmaDef{FSimplify}} we introduce an algorithm for the simplification of large sums of diagrams. \mathem{\mmaDef{FSimplify}} can detect identical diagrams and performs the following steps to find all matches and sum them:
-	%
-	\begin{enumerate}
-		\item All Diagrams with exactly the same content of objects and the same set of open indices are grouped together.
-		\item Each group is then processed in parallel: Pairs of diagrams are sequentially built and compared.
-		\item The comparison of two diagrams is performed by traversing the graphs of both at the same time and checking for identity.
-		\item If symmetries of open indices are provided, all permutations (with possible prefactors, e.g. minus signs for fermionic permutations) are also explored.
-		\item If the graphs are identical, they are merged. When merging, the second diagram is prepended with a factor containing all signs needed to give it precisely the same index ordering and structure as the first diagram.
-	\end{enumerate}
-
-\end{tcolorbox}
-
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \subsection{Truncating the output}
@@ -1491,7 +1488,7 @@ \section{Comparisons and Benchmarks}
 		\quad Dyson-Schwinger equations             & \cmark  & \cmark  & \cmark \\
 		\quad Flow equations (fRG)                  & \cmark  & \cmark  & \cmark \\
 		\quad (Modified) Slavnov-Taylor id.         & \xmark  & \cmark  & \cmark \\
-		\quad Composite operator equations          & \cmark  & \xmark  & \xmark \\
+		\quad Composite operator equations          & \cmark  & \xmark  & (\cmark)\footnote{Although \FunKit does not provide these natively, they can be easily implemented by hand by constructing the objects with \texttt{FDOp}.} \\
 		\quad Arbitrary master equations            & \xmark  & \xmark  & \cmark \\
 		\quad Multi-index func.\ derivatives        & \xmark  & \xmark  & \cmark \\
 		\midrule
@@ -1554,6 +1551,17 @@ \section{Comparisons and Benchmarks}
 \end{figure*}
 
 
+%%%%%%%%%%%%%%%%%%%%
+\section{Limitations and Important Notices}
+
+While \FunKit covers a broad range of applications, of course some limitations remain. Truncations are specified as explicit lists of field-content tuples, meaning that rule-based truncation schemes — such as retaining all operators up to a given mass dimension or derivative order — must be currently constructed manually by the~user.
+
+A fundamental challenge is the resolution of functional derivatives, which involves a product-rule expansion that can lead to rapid intermediate expression growth for large truncations.
+Although \FunKit mitigates this through in-loop simplification parallelisation and appropriate algorithm design, the scaling remains a practical bottleneck for very large systems. This is however not a problem of \FunKit, but rather of the approach itself.
+
+Also, while \FunKit generates optimised code for the integrands of functional equations, it does not provide a numerical integration framework; the user must embed the generated code into their own solver or use an existing framework such as \texttt{DiFfRG} \cite{Sattler:2024ozv}.
+Finally, direct support for Windows is currently not available, as FORM does not support native execution on Windows systems. However, using \FunKit via WSL (Windows Subsystem for Linux) is possible.
+
 
 %%%%%%%%%%%%%%%%%%%%
 \section{Conclusions}
@@ -1571,14 +1579,6 @@ \section{Conclusions}
 
 We demonstrated the capabilities of \FunKit at the example of Yang-Mills theory, scalar field theory, a Yukawa theory and an NJL model. As for master equations, we show DSEs, the Wetterich equation, the modified STIs and dynamically reparameterised flow equations. All these examples can be found in the \FunKit repository, see also \Cref{tab:examples}.
 
-While \FunKit covers a broad range of applications, of course some limitations remain. Truncations are specified as explicit lists of field-content tuples, meaning that rule-based truncation schemes — such as retaining all operators up to a given mass dimension or derivative order — must be currently constructed manually by the~user.
-
-A fundamental challenge is the resolution of functional derivatives, which involves a product-rule expansion that can lead to rapid intermediate expression growth for large truncations.
-Although \FunKit mitigates this through in-loop simplification parallelisation and appropriate algorithm design, the scaling remains a practical bottleneck for very large systems. This is however not a problem of \FunKit, but rather of the approach itself.
-
-Also, while \FunKit generates optimised code for the integrands of functional equations, it does not provide a numerical integration framework; the user must embed the generated code into their own solver or use an existing framework such as \texttt{DiFfRG} \cite{Sattler:2024ozv}.
-Finally, direct support for Windows is currently not available, as FORM does not support native execution on Windows systems. However, using \FunKit via WSL (Windows Subsystem for Linux) is possible.
-
 \FunKit is already a basis for several on-going projects in the fQCD collaboration \cite{fQCD} involving large QCD truncations with dynamical hadronisation and other flowing reparametrisations.
 As it is embedded in the tools of the fQCD collaboration, e.g. it has become the symbolic backend of the \texttt{DiFfRG} framework \cite{Sattler:2024ozv}, \FunKit will continue to see improvements in the future.
 
@@ -1708,7 +1708,24 @@ \section{Superindex Notation Details}
 \begin{align}
 	\textrm{Sym}_{\phi_1\phi_2\phi_3q_4q_5\bar{q}_5} = \frac{1}{3!}\frac{1}{2!}\frac{1}{1!}\,.
 \end{align}
-
+%
+When building a DSE, \FunKit assumes the following form of a classical action:
+%
+\begin{align}
+	S[\phi] = \sum_{\{i_1\ldots i_n\} \in \text{Trunc}(S)} S_{i_n\ldots i_1} \phi^{i_1}\phi^{i_n}\,,
+\end{align}
+%
+where $\text{Trunc}(S)$ represents the set of all (ordered) correlation functions included in the truncation list for $S$.
+As an example, this results in a classical action for the Yang-Mills theory that reads
+%
+\begin{align}
+	S_\textrm{YM} &= S_{A^{i_1}A^{i_1}}A^{i_1}A^{i_2} + S_{c^{i_2}\bar{c}^{i_1}}\bar{c}^{i_1}c^{i_2}
+	\notag\\[0.5ex]
+	&\qquad + S_{A^{i_3}A^{i_2}A^{i_1}}A^{i_1}A^{i_2}A^{i_3} + S_{A^{i_4}A^{i_3}A^{i_2}A^{i_1}}A^{i_1}A^{i_2}A^{i_3}A^{i_4} + S_{A^{i_3}c^{i_2}\bar{c}^{i_1}}\bar{c}^{i_1}c^{i_2}A^{i_3}\,.
+\end{align}
+%
+This is identical with how \QMeS defines its classical action.
+However, \DoFun adds an additional minus sign for fermionic vertices \cite{Huber:2011qr} when constructing the classical action - special care to this should be taken by users when comparing or porting existing \DoFun code to \FunKit.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{NJL Model Example}