New Features in FeynCalc 10

Okay. Hello and thank you for joining this talk. It's a great pleasure for me to introduce new features of Mathematica package fine called 10 based on a publication that was uploaded to Arxiv December last year, done in collaboration with Rolf Mertig and Ferdik Orlana. And let me shortly go to the outline of my talk. First I will try to motivate a bit. What is it all about and what is the purpose of this new features? Then I'll talk a bit about Fine Cut using FINE code Multloop calculations. I'll talk a bit about an extension of Fine Cut for connecting it to other tools that are useful in this context. And then I'll provide a summary and an outlook. Well, I apologize in advance that since this package is being used in high energy physics, unfortunately there'll be a lot of jargon used. So. So if you're not really aligned to the field, it might be a bit difficult to follow. But of course you can interrupt me anytime and ask questions. So let's start with the motivation. I mean, the idea is that if you're talking about perturbative calculations in high energy physics, or particle physics if you want, then Feynman diagrams is basically our main approach to calculate higher order corrections. It might be not the most clever way to do it, as some publications have pointed out, but still this is something where we have most accumulated most of machinery and knowledge. And so at the end of the day, we just continue applying it over and over to different series and processes. And since we know that lhc. So the Lake Hadron Collider at CERN is going to be upgraded to the so called High Luminosity lhc, meaning that much more collisions will take place and so much more data will be collected. And also there are some future colliders, possibly the pipeline. It's also kind of clear that the experimental precision is going to improve in the coming years. And if the experimentalists are able to shrink their errors, then it means that theory necessarily has to keep up. So precise theoretical predictions are also necessary. And in our field. So in the field of high energy physics, high precision usually means calculating more loops, where loops means going to higher orders in the perturbative expansions or calculating more increasingly complicated Feynman diagrams. And it's also kind of clear that you cannot do it by pen and paper, as some people might think, because if you think of theoretical physics, you might have this romantic image of a person doing everything with their notebook. It's not really the case here. In this Field we do a lot of things using computers and we automatize a lot. However, as far as the automation is concerned, only lower orders of perturbation theory have been automatized to the extent that they can really be used by everyone going to higher orders or so called multi loop automation is something that people are currently working on. But it's kind of long and tedious endeavor and probably it will really take much more time to arrive to the same level of automation that we have for lower orders for tree level and one loop calculations. And in principle there are like two main routes that people are trying to follow. On the one hand basically writing completely new codes from scratch that can be used for this purpose. On the other hand, trying to take existing codes and upgrade them to support more loops or higher orders. And even though both approaches have their pros and cons, I would like to talk about something that people kind of do in practice still, because this multi loop calculation, something that people have been doing since many years, perhaps not in an entirely fully automated fashion, but still this is something where the community has accumulated some experience and this is usually being done by so called self written codes that are tailored for the specific process. So maybe to shed a bit of light why it's so difficult to make it fully automatic. Well, it's mainly because doing it foolproof so that the person can just enter the process and hit enter requires dealing with merit potential pitfalls. The so called issues of Gamma 5 extended so 5th D matrix, extended dimensions, then infrared divergences, phase based integration, DLN with master integrals, renormalization for getting away from the UV divergences, and so on and so forth. However, the point I would like to make is that some parts of this multiple calculations actually easier to streamline than everything else. And for that matter I would like to focus on the evaluation of the so called bare scattering amplitude called M. Because using something called optical theorem, we can extract quantities that we are mostly interested in from this renormalized matrix amplitude from the normalized amplitude, namely cross sections and decay rates. So now let me become a bit technical and talk a bit how we would try to calculate this object. So the first step is usually to generate the Feynman diagrams for the given process that you're looking at. And for that what people mostly use is a tool called QGraph. It's a Fortran code that has been written in the early 90s and actually is still being maintained. And the main advantage of this code that it can deal with enormous number of diagrams, even millions of them. In a very fast fashion. The next step is to do the algebraic simplifications of the corresponding amplitudes. So what people usually use here is a symbolic manipulation system called form, which written by Joster Matheren, who's also a particle physicist. And then once you do the simplifications, you can extract the integrals that appear in your calculation. The next step would be to reduce them, because as we know from particle physics, not every integral appearing in an amplitude is unique. But in fact, usually these integrals can be reduced to a much smaller set of the so called master integrals. This is called reduction using integration by parts identities. And there are automated code such as Fire, Kira or Litrate. By the way, Light Red is actually a mathematical package that can do this reduction for you. Then the step number four would be the actual calculation of the master integrals. This step is a quite non trivial one because calculating master integrals is still something where you need to have some physical insight. It's not easy if you want to calculate them analytically. There are lots of different techniques and methods and you don't usually know in advance which of these techniques will work for the particular integral. Calculating them numerically is a bit easier because there are tools that can automatize that. But essentially I just want you to be reminded that this step is a highly non trivial one and that at the end of the day you kind of assemble the final amplitude. Again uses this form code. And the claim I'm trying to make is that apart from the Step 4 evaluation of the master integrals, all other steps are something that we understand pretty well. I'm not saying that the steps are trivial because there are always some issues that can arise here and there, but the issues arising there are usually of kind of more computer science nature. Meaning that perhaps your code is not efficient enough, you need to hunt some bugs, you don't need enough computer, you don't have enough computer power, and you have to run on a cluster. But these issues do not really have to do so much with physics. While step four is something where you need a physical understanding, but essentially other steps is something one could automatize pretty well. Well, the problem is also that in our field a lot of people are actually pretty secretive in a sense that they have developed some private codes over the years and, and they're still using them, but they're not willing to share this code. So make them public, partly because they don't want to support them, perhaps also for the reason that they want to have some advantage over their competitors. Although luckily the sync is also starting to change in the recent years because there have been some codes published the last couple of years that try to automatize some of the steps. And so one may hope that things are getting better with younger people coming who are more geared towards open source and public codes. And in this context also I would like to talk about our contribution to this part using the code that we are working on with my collaborators called FineCalc. So FineCalk is actually a computer algebra package, a mathematical package for high energy physics calculations that have been there on the market since early 90s. So the first publication of Feinglc came out 1990 and then I joined this project in 2014 and I've been involved in the subsequent publications with the newer versions of feinglc. So those who are know it probably would confirm that it's a very flexible and versatile package that can be used in many cases where you need to know exactly what you are doing and you want to have full control over how you do it. And most people who use FinalCL probably mostly have been using it for three and one loop calculations because previous versions of Fine Calc were not really able to do multi loop. But with the version 10 that came out December last year, we tried to improve on that and add some features that actually allow you to perform some multi loop calculations within Mathematica. Of course, if I'm making this kind of statements, I have to do some disclaimers so that I'm not being understood wrongly. I mean first of all, this so called IBP reductions that I mentioned before. So the reduction of a large number of loop integrals appear in your calculation to a small set of master integrals. It's not part of feingalc, but there are actually interfaces available from finecalc to programs that can do it. The same goes also for the diagram generation, but again there is an interface to tools such as QGraph or also fine Arts that can handle it. And the third point that I also have to stress, I mean we are not really advocating doing multiple calculations in Mathematica. The reason being that unfortunately Mathematica's performance is often not adequate for cases where you really have to deal with millions of terms. But the statement I'm willing to make is that in some cases when you want to do a multi loop calculation, but the number of diagrams is not that large, and also the algebraic complexity complexity is not overwhelming, you actually will be able to do it within Mathematica using Fine Calc and those corresponding interfaces. But I also would like to mention that also working on a kind of another set of follow up calculations which is based on form, but is using Mathematica at some intermediate stages which are not performance critical. So even though this is still something work in progress, it's just that I would like to have it mentioned at this point. So let me talk a bit about now using fine multiloop calculations and how it all has been implemented. So in Principle There are three building blocks that are used in FindClik to add all this functionality. So one of them is called FC topology. So FC topology is a symbol that basically denotes your integral family in finecalc. It clearly has a name, it has a list of propagators. So propagators are denominators of your integral. It has loop momenta over which you integrate. It has the external momenta on which your results will depend. It also has a list of kinematic constraints, so for example that some momenta squared are assigned particular values. And it also has a slot for result for future additions then integrals that belong to these families of this form. So so basically they also have an id, they're called gli, it's a shortcut for generic loop integrals and they have a list of the propagator powers where propagator powers denote the powers of the denominators appear in this propagators list. And then there is a function called fcfinemanprepare that basically being given loop integral or loop integral family can compute the so called semantic polynomials U and F. So explain in a minute why those polynomials are needed. But let me also mention that the syntax is not really unique, I mean you can find it also in other tools for multi loop calculations. So for example like FAR or light thread or pysect. So in that respect it's not something that I invented, but it's rather something that I adopted from other clever people. And in addition I would also like to mention that basically Finecal 10 has lots of new functions that will work with these GLIs and C topology symbols so that you can really take full advantage of this new functionality. And last but not least, I would also like to mention that this multilook functionality has been very much inspired by a mathematical package called Topoid by Jens Hoff. So Jens ho was a PhD student at Kit University of Karlsruhe where I also was doing my postdoc and basically in his PhD thesis he collected a lot of very useful information about implementing this multi loop algorithms within Mathematica. And the Stop ID package was a kind of proof of concept for this, which also can be found on GitHub. But unfortunately at some point he left academia and and so this package remained not entirely finished and not entirely documented. But I would like to really mention that I adopted a lot of functionality from there, which is also fine since it's open source and it went into another open source package, because FineCoc is also open source as well. But again, I gratefully acknowledge the legacy of Jens Hoff and his code here. So now let me talk a bit about loop integrals. So one important feature concerning loop integrals is the so called propagator representation is not the most useful way to write them down. So here you have an example of such loop integrals. It depends on loop momentum Q&2, external momentum P1 and P2. And the main feature of this and many other loop integrals which are regularized using so called dimensional regularization is that they have a shift invariance. So if I make a shift of the loop momentum Q to go into Q +P1 +P2, I get another integral that looks a bit different from the original one, but actually these two integrals are identical. So if I calculate them explicitly, either analytically or numerically, I will get exactly the same result. And now you can understand the complications that given two loop integrals you can always ask if there is some set of shifts that will convert one integral into another one. And even though naively you might try to just enumerate all the shifts by brute force, probably would soon understand that if the integral is a bit more complicated, then this is a completely hopeless task. And so one needs some kind of more efficient algorithm for doing this. And the more efficient algorithm actually consists of representing these integrals through the so called Feynman parametric representation or graphs. Although I will not really talk much about graphs in this talk. And this fine called parametric representation in this context looks like this. So this is a generic formula for converting and loop integral into this Feynman parametric form. And what I would like you to to focus your attention on is that here it depends on two polynomials U and F and that we have to integrate all so called Feynman parameters going from x1, x2, x3 and so forth. And basically this polynomial U and F called semantic polynomials or graph polynomials tend to encode most of the integral properties. I mean there are also nice summaries about them in the correspond literature. And so the nice thing that once you switch to this form, this ambiguity under shifts of loop momenta that you can change make a Shift and the integral though remaining the same, will look different is gone, but there is still some ambiguity remaining under the renaming those final parameters. Because basically since it's an integral in these parameters X j, you can just make a renaming, for example, X1 goes to X2 and so on, and the integral will not change. And so the idea is that first you basically design a function of these two polynomials and the propagator powers mi to characterize your loop integral. And then you try to find a canonical renaming of this Feynman parameters XI in such a way that the function becomes unique. And once you get this unique function, you can basically map every loop integral to such a function and then compare them. So if you have two different integrals, you do this mapping to the corresponding function. And if you see the two functions identical, you know that your integrals should be identical as well. So this approach is called PAC algorithm, which was designed by Alexey park, who also has worked in Karlsruhe Institute of Technology. But much before I was doing my postdocs there. And in fine cut this approach is implemented into functions called fcloop find topology mappings and fcloop find integral mappings for finite mappings between topologies and integrals correspondently. So let me explain this thing in a bit more details. So basically the idea is that given this polynomials U and F, which you can always calculate for loop integral, you can introduce a so called characteristic polynomial which can be a product or a sum of the functions. And this polynomial will depend on the finding parameters xi, but it's still not unique, because in a sense the ambiguity under shifts of loop momenta is translated into the ambiguity under permutations of this final parameters xi. And so given a polynomial P, you can always get a new polynomial P prime by just permuting this momenta. For example, by making a exchange x, one goes to x 2 and this function will still describe the same integral. And so the task is to find some kind of canonical ordering of this Feynman parameters in the given polynomial. And the solution is exactly this algorithm by Alexey Pak, where what you do is roughly is to write P as a matrix, and then by swapping or sorting rows and columns of this matrix, you can find a canonical form of it. So here's an example of such functions. So here for this representation of a loop integral, it's a tadpole with three different masses, you can calculate this Feynman parametric representation where U and F are the above mentioned semantic polynomials, and you see that they depend on the Feynman parameters x1, x2 and x3. And if I would exchange, let's say x1 with x2 or x1 with x3, basically not much will change. So it will still give me. It will give me a characteristic polynomial that will look differently, but the result of the integral will be the same. And this is why we are looking for some way to rename these polynomials canonically to have a fixed ordering. Let me now explain this algorithm a bit, just to show you how it works. So if you take this characteristic polynomial P basically containing l terms and Feynman parameters, we can write it down as a matrix. Basically it's a matrix that has it's l times n plus one matrix. And here we can have an example where we have C2x2x3 plus C1x2 squared C2x1x3. And now basically we are writing as a matrix where the first column are the prefactors. And then here we are writing the power sub parameters. So for example, x1 comes with the zeros power, x2 with the first power, x3 with the third power. So we write 01,1. Here we have only x2 raised to second power, so it's 0 to 0, and so on. And then this matrix you can call M01, 2, 3. And then in the first iteration we basically switch the second column which each of the next columns and we keep track of the permutations. This gives us new matrices. So basically we make the switches. This is original matrix is 1 to 3. There is a matrix is 2 1, 3 and matrix is 3 to 1. Then basically by looking only at the first two columns, we try to sort this matrix matrices by basically arranging the rows. Let's say, except for graphically. So we have M tilde 01, 23 because we've been reordering the rows here, here and here. And we have the same for 2, 1, 3 and 3 to 1. And then we basically extract the this case the second columns of this matrix. So and we try to find which one of these columns is the largest one. So we have 0201-0201 and 0011. And if we would let Mathematica do this for us, basically find the maximum vector Mathematica would give us 2, 0, 1. And so then we say, okay, we keep all the matrices containing this maximal vector and we discard the other ones that do not contain it. And so we get the final set of matrices in this iteration. And then we essentially repeat this iteration again. So again in second iteration we will again do a permutation and do the sorting. And after doing it again we'll basically will end up with the maximal vector being 2 010, because now we are looking at the already third rows here and here and here. And so we'll again keep two matrices and at this point the iteration actually stops because we already have studied all the rows. And what do we get from this matrices M1 tilde and 1 2, 3 and M1 tilde 2 13. Well, basically we get the symmetries under the renamings of the final parameters 123 and 21 3, which are basically this upper indices. And this means that basically P1 23 and 213 are equivalent. But it also means that we can just take a particular renaming in this case 1 to 3, meaning that we keep everything as it is, and this polynomial 1 to 3 will be our characteristic polynomial for this integral. So in a more complicated integral we'll get more renamings, but still the first one will be the one that is characteristic one. And so by using this approach we can basically always assign a unique characteristic polynomial to every integral and then we can just compare these polynomials and say if the integrals are identical or not. So now let me come back to implementation FineCalc. So here how it essentially works. Well, the idea is that if you have fine calc 10 and you want to calculate the amplitude IM, you would start the usual way. As you perhaps know if you've used older versions of FineCalc by using commands such as dirac simplify or scn simplify to deal with algebra, then you would identify all the current topologies using the function F topologies. And in cases, if your sets of propagators are over determined or incomplete, there are also functions to deal with that. Then you will also find out which topologies, whether the topologies you have identified also have some non vanishing sub topologies, meaning that you will check how many propagators you can remove without renderings of all integral family vanishing. And then after you have done this, you can minimize the number of topologies using the function absolute, find topologymappings and then basically with these mappings, applying them to the amplitude using the function fcloop applied topology mappings, you will end up with the amplitude litten as a linear combination of glis, where the next step would be just to perform an IBP reduction, reducing these glis to master integrals, inserting the reduction tables into the amplitude, also looking for one to one mappings between master integrals, and finally inserting analytical numerical results for the master integrals. To to obtain the final value. And at this point I would also like to demonstrate a few examples how it works. But the main statement, I would like to make that now with Fine Falcon it's indeed possible to calculate also more than just one loop. So let me just basically break out from the talk and go to an example I would like to show. So let me, let me now open it here. So this is a process of the gluon to gluon self energy in qcd quantum chromodynamics, theory of strong interactions, where I will show you how to calculate it in the case of masses corpse. So this is the example, I hope you can see it well. So here at this point we are loading FineCalc to the kernel and we will also use another package called fine arts to generate Feynman diagrams. So here we are doing this generation of Feynman diagrams with the help of fine arts and we can see the diagrams that we need to calculate. So, so this is a process of gluon going to another gluon at two loops. So we can see purely gluonic diagrams. We can also see contributions from quarks and from ghosts and there are different kinds of these diagrams. And then the next step will be to obtain the amplitude for the corresponding diagrams, which we can do using the function FCFA convert. So people who have been using previous versions of fine Dr. Should probably be familiar with this. We define the scalar product of the external momentum with itself to be called pp and we will use a so called projector. So meaning that I will not do a tensor reduction here, but I will basically use this projector and contract it with my amplitude to project out the scalar functions that I want to calculate. So this is what I'm doing here. I'm multiplying the projector with the amplitude, I'm setting the cork masses to zero. Then I'm doing contractions for Lorentz indices, simplification of the Dirac algebra and simplification of the color algebra. And in this case I'm doing the calculation the Feynman gauge and the chord mass is zero. This goes through very, very fast. And then we have our amplitudes here still written in the explicit propagator representation. So so far this is nothing new compared to the older finecalc versions. But now comes the magic where we are using functions that were introduced in FineCalc 10. So first with FCloop Fine Topologies, I can identify the topologies appearing in this amplitude. So at this point these are just naive topologies that have not been minimized yet. So finecalc actually finds five of them which are shown here. Then I'm also doing a search for sub topologies, meaning that I want to see how many non vanishing sub topologies are contained in this topologies that have been found and there are more of them as you can see here. And then I'm finally performing the minimization of the topologies and by doing so I can actually show that there's only one non once non trivial topology remaining. So here at the output you can see that topologies 2, 4, 5 and 3 can be all mapped to only one single Topology FC Topology 1. And here you see this topologies, the shifts of the loop momenta and also the explicit mappings for the loop integrals given as a set of different rules. And now with these mappings I can just apply basically the mappings to the my amplitude. So in this case, since I'm not doing turn the reduction because after I applied the projector everything is color ready. So this function absolute turn the reduce is not really necessary, but I'm just exclude including for the sake of completeness, then I'm applying this function fcloop applied apology mappings to the reduced amplitude. And you can see that at this point this amplitude is a kind of mixed state. It's a collection of numerators that still depend on external momentum and loop momenta and denominators that are containing information about topologies. But now after appliances function FC loop applied topology mappings, my amplitude now will look in a bit different way. So the amplitude will now be linear combination of these GLI integrals like this. So you see there is a G Fctopology 1 is the idea of the integral. And here I have the powers of the propagators as arguments. And then I can usually apply some more. Diracan's color algebra simplification depend on the type of the amplitude I'm calculating. And then I basically have this final amplitude. And from here on the next step will be to do the ABP reduction. And as I mentioned, actually there is an interface to this, but it's not part of FineCalc but of this extension fine helpers in principle here there is a code commented out that will do this task basically reducing these integrals using a code another package called fire and then inserting them back into the amplitude. But here let me just assume that it has been done already. So I can just load a reduction table that was pre made for this calculation and it's also shipped together with fine calculated. So Loading this table, which basically looks like this, so it's called reduction table because you see that the loop integrals with different indices are reduced to simpler integrals multiplied by some prefactors. I can now just apply this table to my amplitude as a replacement rule. I can add up all amplitudes together using total and then I collide them with respect to the remaining integrals with construction, collect two GLI and then this is how the sync looks like. And then usually it may also happen that some integrals after this reduction from different integral families are actually identical. And define this identical integrals. I can use a function FC loop, find integral mappings. And it did, and finds one mapping between different integrals. And upon applying this mapping I can get finally get my final result written in terms of loop integrals. And then the next step would be actually to calculate these integrals. I mean in general, realistic calculations that probably would be the toughest part if the integrals are not known yet, but perhaps if they've been calculated in the literature, you would just need to find this results analytically and insert them into your amplitude. And for this particular case, the integrals actually are so simple that you can just calculate them within feincalc, which also has been done here with this code that I commented out to make it a bit shorter. So here in this example just include explicit replacement rules for the nymph results of this integrals and then upon inserting them in the amplitude as a reduction rule, setting the dimensional parameter D to 4 minus to Epsilon and just expanding all this business around epsilon to zero, I can get my final result which contains poles and epsilon and the final part. And then I can compare this to the literature. Basically similar calculation has been done in a paper of Davidic of OSN and Tarasov from 98 and they also kindly provided the results in their paper. And so I can compare this literature result here to the result of my calculation and they find a full agreement. And if I would run this through, it would only take around 33 seconds. Good. So this is the example I wanted to show you. So let me now go back to the remainder of my talk here. I would also like to mention a couple of functions that are not directly related to this amplitude calculations, but are quite useful in finecalc. So one of them is called fcloop integral to graph. So this is a function that can basically convert your loop integral in the propagator representation to a graph which can then be plotted using Mathematica. This can be particularly useful if you are doing your calculation and at some point you have your list of master integrals and you would actually like to understand how this integrals look like. This is not always possible because the algorithm is a bit brute force, but in most cases it just works. And in the manual you can also see some more complicated cases where you need to tune some options. But from my personal experience, in a lot of cases just works out of the box. And it gives you this nice graphs that you can use for your own information or maybe for showing to your colleagues. Well, another function that is also very useful is basically the derivation of this final parametric representation for a given loop integral. So here you can just enter this integral in the fine club notation if you want. You can also plot it using this fcloop integral to graph. And then using this function fcfine parameterize, you can immediately get the Feynman parametric representation and you can also get this U and F polynomial separately. And the nice thing that it really works for a wide class of loop integrals and it actually works for any number of loops. So it can be quite convenient again for your calculations. So function number three or another one that I would like to mention is called FC match solve. So the idea here is that when you are doing particular kinds of calculations like randomization or matching, and then basically we'll have two amplitudes, and then you take the difference of this amplitudes and you would like this difference to vanish term by terms. So you would kind of collect it by special structures that have to vanish separately. And then you would like to mathematically to solve it for the free parameters that you have in your expression and to determine the values of these parameters. And in practice it can be kind of tricky because Mathematica solve somehow often does not like systems of equations that have lots of different parameters. But with this function you can basically just take this expression collective with respect to the structures that are relevant for you. For example, here collected to respect this OPQ and OPQs structures. And then you can just tell it, okay, make this expression vanish under the condition that the objects in the list are not allowed to vanish. So OP&C reflect our pref are some parameters that are already fixed, but all other parameters in the expression can be chosen freely in such a way that this expression must vanish. And then this function will give you a result if there is a result. And say, okay, this parameter ZZ24 and ZZ44, if you choose them in this way, then this expression will vanish term by term. So this is really very practical. Then another function that Is there now is called fccompare numbers. So here the idea is that when you're doing numerics for your calculation, and perhaps you're doing it together with your colleague, and at some point you want to compare the results. As you know, comparing numerical zots can be tricky because Floyd and point numbers are never exact. But usually it's sensible to demand that your numerical exert should agree up to some number of significant digits. And with these functions you can easily do this kind of constraints by saying okay, if I compare left hand side and right hand side, by default the number of significant digits sectors set to 6 and chop. So basically everything smaller than 10 to minus 10 will be just chopped off. And then you have a full agreement. But then if you would increase the number to eight, the function will show you that there are some pieces of your expressions that do not agree up to eight significant digits, but they agree up to only, let's say, six, as you can see here. And when debugging numerics, this thing is also enormously useful. Also from my personal experience. And last but not least, another thing I would like to mention is a function for reordering of the terms in Mathematica. So this is a kind of problem that I guess all people doing research with Mathematica has experienced at some point that when you are done with the calculation and you have your expression, you would like to export it to latic to be able to publish it. But then the problem is that just applying tekform to expression usually does not give you what you want, because as we know, Mathematica has its own way to order terms. And this mathematical ordering often does not coincide at all with the ordering we would like to have in a paper. And so for that matter we added this function called FC2Tech reorder where you can very precisely specify what kind of ordinance you would like to have in your expressions, including the brackets and sub brackets and so on. And then mathematically, and then the output will be used will be using lists here to preserve the ordering. But then if you apply the function FC to Tech Preview term order, it will basically give you the output as you would like to see it in a paper. And if you like the output in this shape, you can just apply tag form to it and and just copy and paste it into your paper. So this really can save you a lot of headache because otherwise you would have to start reordering temps by hand in latex, which can be a lot of pain and can be also very much error prone. Okay, now Let me say a few words about this other thing. Basically about an extension of Fine Helpers, which is a collection of interfaces to other useful tools. So the idea behind this approach is the following. Basically there are a lot of tools that have been developed for the purpose of loop calculations by our community. I mean, here I'm showing only a few of them, There are of course much more. But the problem with using these tools is essentially that when you want to employ them in a real calculation, there are often issues that this every tool has its own input and output format and if you want to combine them into one single tool chain, usually you need to somehow make a conversion between this input and output formats. So in practice you end up writing a lot of glue scripts, be it Mathematica or Python or Bash. And even when you are done with that, usually the scripts are highly specific to the process you're calculating and not really portable. And so then the idea was to use Fine calc as a sort of common denominator because now we have this format for integrals and topologies to be able to exchange results between these different programs. And the idea was basically at this point to include interfaces to the tools that personally found particularly useful when doing my research, namely the packages called QGraph for the diagram generation, package X for analytic calculations of one loop integrals, loop tools for numerical evaluation of one loop integrals, and then Phar Kira for IBP reduction, Fiesta and Pisec Deck for numerical evaluation of loop integrals and Fermat for solving of linear equations. Symbolically and essentially this interface is actually already quite easy to use and fully documented even though it's not has not been published yet. But it's available on GitHub so you can, if you're interested you can just install it. It's the same repository as a final GitHub repository. And so let me just give you a bit of examples how you might want to use it. So if you are doing notebook calculation, the main point will be here. So basically once you're done with evaluating the amplitudes and fine calc and you be able been able to write the amplitude as a linear combination of GLI integrals, what you would do is then basically use find helpers to create run cards for Phi or Kira, then do this IBP reduction and then plug the results back into Mathematica and then continue with the calculation. If you are basically want to use it in a form based setup, so essentially not using that much Mathematica, then the idea would be that you would evaluate your amplitude mostly in form, but then you would export the topologies shown in the amplitude to find calc. Then you would use fine calc to minimize the topologies and write everything in terms of integrals. You will then export these rules obtained by fine calc to form and apply them to your amplitude. And then again you will use fine helpers to generate the run cards for the IBP reduction, although the IBP reduction itself will be done on a computer cluster, let's say. And then again you can insert the results of your amplitude into your amplitude using form and finalize the calculation. So to give you an example how this works a bit, let me explain briefly how this is done with fhir. So FHIR is a program for EBP reduction where the ingredients you need is a list of integrals and topologies. And then using high level mathematical functions of this interface, you can actually carry out all this reduction completely within a notebook, although it might not be always recommended for complicated cases. So let me show you here. So here you have an integral family written down as FC topology, where you have the name of the topology, the propagators appearing, the loop moment as external momentum as the kinematic constraint, and you have some list of loop integrals that you want to reduce. So then you can do the following. First you prepare the so called start files that PHAR will need to carry out the reduction. These are so called Mathematica scripts that have to be run and in general, depending on the complexity of your integral family, it might be that you would need to run it on a server or on a cluster. But for cases where the complexity is low and everything is very simple, you can actually run it in the background from Mathematica using this file create start file function. Then you also need to create so called configuration files where again it's just enough to give the functions the topology or integral family you're working with. You also need to create the list of integrals, which again works quite easily with the list of this integrals and the integral family. And then again, if everything is simple enough that you can do it on your laptop, you could also just use this fire run reduction command that would run the reduction in the background and after it's done you can just use this far import results function to import the results of this reduction into Mathematica and then you can use these results at your leisure to continue with the calculation. So that sense this exactly goes the direction what I was saying that in general you might not be able to do any calculation with Mathematica for different reasons. But if your calculation is really simple enough, you could be able to pull it through completely in a notebook using Finecock10 and this fine Helpers interface. And what else I would like to mention at this point that Find Helpers is just a mathematical code. So you also still need to set up all the tools that you want to use on your own. And in many cases it also means compiling from source or which means that it probably would be best to use a Linux system for it, or at least macOS, because with Windows it can be a bit complicated. And I also would like to say that you should not expect that you would be able to do everything on your laptop or desktop, because serious calculations will require a lot of computational power and that often goes the direction of computer computing cluster. And of course if you have at least some basic understanding of how these tools work, that would be highly beneficial, although in practice this might not be necessary. And here just some links to the manual and the GitHub repository for this interface. So now let me just summarize and provide some outlook. Well, I hope I could convince you that Final Tender is really now capable of doing multi loop calculations. And it's useful not only for people who just use Mathematica and nothing else, but it also can be useful for people who or using form, which applies to most of people in the Multilook community, as I mentioned several times. I mean a lot of these algorithms and ideas have been adopted from other tools developed by people from our community and I'm really sincerely grateful to them. And if you're interested to try it out, you can just install it in a Mathematica notebook and go on working with it. So a big advantage of finecast is also that now we have a proper documentation for everything as well. So the documentation has a web form where you can just go to this link, but there is also proper PDF manual and if you have questions or comments, there is also a forum for discussions. And as an Outlook I would say that basically topology identification, so which is the main feature of final 10 is mostly not a performance bottleneck because actually in the development version in the meantime it can also be parallelized. So for the time being it's sufficient. But what we'll need for the future is to have a bit more flexible setup, also using form to be able to tackle real realistic big calculations. And this is something goes under the name of Loop Scala that I'm also currently working on and that you can see the current stage of it on GitHub. So there are still some exciting developments going on and you can stay tuned and follow them. At this stage I'm actually done with my talk, but I guess there might be some questions from your side so I can stop talking and I'll be happy to answer any questions that you have. Thank you for your attention. How long did it take to develop fanhalc? Well, it actually took a lot of time. As I said, the final cut has been in constant development since 90s, so you can say almost 30 years. But in particular this multi loop functionality is something that I started to add around 2018, so that would be around six years and probably it was mostly done around 2022, but then more time was needed basically to debug things and to test them on realistic examples and make sure that it really works as intended. So I hope this answers the questions. Okay, there's another one. I'm curious to see how this evolves over time relative to the tools evolving for the physics projects as well. Okay, I think it's more as a comment if I understand it correctly. Well again if I may comment on this as the evolution is that obviously with fine calc alone there are not so many calculations you can tackle, even though this multi loop functionality and this fine helpers interface allows you to do a lot more than you could previously. It's also clear that if you are talking about real calculations with hundreds thousands, ten thousands of diagrams, this probably will never be able to be done in Mathematica just because mathematical kernel is unfortunately not that efficient handling billions of terms. So here the natural progression would be really to have more hopes than loop Scala in a sense that loop Scala will be able to handle much bigger projects or calculations due to using form. But still it will be connected to Mathematica because it will be used fine called for things which are too cumbersome to implement and form, such as for example topology identification or calculations of loop integrals one to one mappings and so on. Okay, so there is another question. How much time does it currently take to support and develop the project? Well, it depends. I would say that I'm constantly using doing it, but on the other hand it's not that much work because I'm also using fine calculation on my own a lot. So I'm using and adjusting it for my personal needs and it's usually not that common often that I have to do something that is completely unrelated to something that I'm doing. So yeah, I would say maybe perhaps couple of hours per week if it's a quiet week, if it's some bugs that I have to debug. It can be more hours, but in principle, luckily we have at this point lots of unit tests. Most of functionality is just working. So unless I really start to work on something where I need understand that I need new functionality and I have to edit, it's not that much time. So okay, there are no more questions as far as I can see. So thanks again for listen to my talk and forgive me the opportunity to present it. So stay tuned and let's see how it goes in the future. Thank you and goodbye.