diff --git a/doc/source/refs.bib b/doc/source/refs.bib index e6796d738..16a662451 100644 --- a/doc/source/refs.bib +++ b/doc/source/refs.bib @@ -1021,3 +1021,14 @@ @article{Falcioni:2023tzp month = "10", year = "2023" } + +@article{Moch:2023tdj, + author = "Moch, S. and Ruijl, B. and Ueda, T. and Vermaseren, J. and Vogt, A.", + title = "{Additional moments and x-space approximations of four-loop splitting functions in QCD}", + eprint = "2310.05744", + archivePrefix = "arXiv", + primaryClass = "hep-ph", + reportNumber = "DESY-23-150, Nikhef 23-016, LTH 1354", + month = "10", + year = "2023" +} diff --git a/doc/source/theory/N3LO_ad.rst b/doc/source/theory/N3LO_ad.rst index 6cee0e11a..34030f7e7 100644 --- a/doc/source/theory/N3LO_ad.rst +++ b/doc/source/theory/N3LO_ad.rst @@ -90,16 +90,16 @@ In |EKO| they are implemented as follows: - The large-N limit :cite:`Moch:2017uml`, which reads (Eq. 2.17): .. math :: - \gamma_{ns} \approx A^{(f)}_4 S_1(N) - B_4 + C_4 \frac{S_1(N)}{N} - D_4 \frac{1}{N} + \gamma_{ns} \approx A^{(f)}_4 S_1(N) - B^{(f)}_4 + C^{(f)}_4 \frac{S_1(N)}{N} - D^{(f)}_4 \frac{1}{N} This limit is common for all :math:`\gamma_{ns,+}^{(3)},\gamma_{ns,-}^{(3)},\gamma_{ns,v}^{(3)}`. The coefficient :math:`A^{(f)}_4`, being related to the twist-2 spin-N operators, can be obtained from the |QCD| cusp calculation - :cite:`Henn:2019swt`, while the :math:`B_4` is fixed by the integral of the 4-loop splitting function + :cite:`Henn:2019swt`, while the :math:`B^{(f)}_4` is fixed by the integral of the 4-loop splitting function and has been firstly computed in :cite:`Moch:2017uml` in the large :math:`n_c` limit. More recently :cite:`Duhr:2022cob`, it has been determined in the full color expansion by computing various |N3LO| cross sections in the soft limit. - :math:`C_4,D_4` instead can be computed directly from lower order splitting functions. + :math:`C^{(f)}_4,D^{(f)}_4` instead can be computed directly from lower order splitting functions. From large-x resummation :cite:`Davies:2016jie`, it is possible to infer further constrains on sub-leading terms :math:`\frac{\ln^k(N)}{N^2}`, since the non-singlet splitting functions contain only terms :math:`(1-x)^a\ln^k(1-x)` with :math:`a \ge 1`. @@ -234,11 +234,11 @@ The other parts are approximated using some known limits: It is known that :cite:`Albino:2000cp,Moch:2021qrk` the diagonal terms diverge in N-space as: .. math :: - \gamma_{kk} \approx A^{(r)}_4 S_1(N) + B^{(r)}_4 + C^{(r)}_4 \frac{S_1(N)}{N} + \mathcal{O}(\frac{1}{N}) + \gamma_{kk} \approx A^{(r)}_4 S_1(N) + B^{(r)}_4 + C^{(r)}_4 \frac{S_1(N)}{N} - D^{(r)}_4 \frac{1}{N} Where again the coefficient :math:`A^{(r)}_4` is the |QCD| cusp anomalous dimension for the adjoint or fundamental representation, the coefficient :math:`B^{(r)}_4` has been extracted from soft anomalous dimensions :cite:`Duhr:2022cob`. - and :math:`C^{(r)}_4`can be estimate from lower orders :cite:`Dokshitzer:2005bf`. + and :math:`C^{(r)}_4,D^{(r)}_4`can be estimate from lower orders :cite:`Dokshitzer:2005bf`. However, :math:`\gamma_{qq,ps}^{(3)}` do not constrain any divergence at large-x or constant term so its expansion starts as :math:`\mathcal{O}(\frac{1}{N^2})`. The off-diagonal do not contain any +-distributions or delta distributions but can include divergent logarithms @@ -257,14 +257,14 @@ The other parts are approximated using some known limits: \gamma_{qq,ps} \approx (1-x)[c_{4} \ln^4(1-x) + c_{3} \ln^3(1-x)] + \mathcal{O}((1-x)\ln^2(1-x)) - * The 4 lowest even N moments provided in :cite:`Moch:2021qrk`, where we can use momentum conservation - to fix: + * The 5 lowest even N moments provided in :cite:`Moch:2021qrk,Moch:2023tdj`, + where momentum conservation fixes: .. math :: & \gamma_{qg}(2) + \gamma_{gg}(2) = 0 \\ & \gamma_{qq}(2) + \gamma_{gq}(2) = 0 \\ - For :math:`\gamma_{qq,ps}, \gamma_{qg}` other 6 additional moments are available :cite:`Falcioni:2023luc,Falcioni:2023vqq`. + For :math:`\gamma_{qq,ps}, \gamma_{qg}` other 5 additional moments are available :cite:`Falcioni:2023luc,Falcioni:2023vqq`. making the parametrization of this splitting function much more accurate. The difference between the known moments and the known limits is parametrized @@ -281,9 +281,9 @@ we need to account for a possible source of uncertainties arising during the app This uncertainty is neglected in the non-singlet case. The procedure is performed in two steps for each different anomalous dimension separately. -First, we solve the system associated to the 4 known moments, +First, we solve the system associated to the 5 (10) known moments, minus the known limits, using different functional bases. -Any possible candidate contains 4 elements and is obtained with the following prescription: +Any possible candidate contains 5 elements and is obtained with the following prescription: 1. one function is leading small-N unknown contribution, which correspond to the highest power unknown for the pole at :math:`N=1`, @@ -317,29 +317,29 @@ final reduced sets of candidates. :align: center * - :math:`f_1(N)` - - :math:`\frac{S_2(N-2)}{N}` + - :math:`\frac{1}{(N-1)^2}` * - :math:`f_2(N)` - - :math:`\frac{1}{N}` + - :math:`\mathcal{M}[(1-x)\ln^3(1-x)]` * - :math:`f_3(N)` - - :math:`\frac{1}{N-1},\ \frac{S_1(N)}{N^2}` + - :math:`\frac{1}{N-1},` * - :math:`f_4(N)` - - :math:`\frac{1}{N-1},\ \frac{1}{N^4},\ \frac{1}{N^3},\ \frac{1}{N^2},\ \frac{1}{(N+1)^3},\ \frac{1}{(N+1)^2},\ \frac{1}{N+1},\ \frac{1}{N+2},\ \mathcal{M}[(1-x)\ln(1-x)],\ \frac{S_1(N)}{N^2}, \ \mathcal{M}[(1-x)^2\ln(1-x)],` + - :math:`\frac{1}{N^4},\ \frac{1}{N^3},\ \frac{1}{N^2},\ \frac{1}{(N+1)},\ \frac{1}{(N+2)},\ \mathcal{M}[(1-x)\ln^2(1-x)],\ \mathcal{M}[(1-x)\ln(1-x)]` .. list-table:: :math:`\gamma_{gq}^{(3)}` parametrization basis :align: center * - :math:`f_1(N)` - - :math:`\frac{S_2(N-2)}{N}` + - :math:`\frac{1}{(N-1)^2}` * - :math:`f_2(N)` - - :math:`\frac{S_1^3(N)}{N}` + - :math:`\mathcal{M}[\ln^3(1-x)]` * - :math:`f_3(N)` - - :math:`\frac{1}{N-1},\ \frac{1}{N^4}` + - :math:`\frac{1}{N-1}` * - :math:`f_4(N)` - - :math:`\frac{1}{N-1},\ \frac{1}{N^4},\ \frac{1}{N^3},\ \frac{1}{N^2},\ \frac{1}{N},\ \frac{1}{(N+1)^3},\ \frac{1}{(N+1)^2},\ \frac{1}{N+1},\ \frac{1}{N+2},\ \frac{S_1(N-2)}{N},\ \mathcal{M}[\ln^3(1-x)],\ \mathcal{M}[\ln^2(1-x)], \frac{S_1(N)}{N},\ \frac{S_1^2(N)}{N}` + - :math:`\frac{1}{N^4},\ \frac{1}{N^3},\ \frac{1}{N^2},\ \frac{1}{(N+1)},\ \frac{1}{(N+2)},\ \mathcal{M}[\ln^2(1-x)],\ \mathcal{M}[\ln(1-x)]` - Note that this table refers only to the :math:`n_f^0` part where we assume no violation of the scaling with :math:`\gamma_{gg}` - also for the |NLL| term, to help the convergence. We expect that any possible deviation can be parametrized as a shift in the |NNLL| terms - and in the |NLL| :math:`n_f^1` which are free to vary independently. + Following :cite:`Moch:2023tdj` we have assumed no violation of the scaling with :math:`\gamma_{gg}` + also for the |NLL| small-x term, to help the convergence. We expect that any possible deviation can be parametrized as a shift in the |NNLL| terms + which are free to vary independently. Slightly different choices are performed for :math:`\gamma_{gq}^{(3)}` and :math:`\gamma_{qq,ps}^{(3)}` where 10 moments are known. In this case we can select a larger number of functions in group 3 diff --git a/extras/n3lo_bench/plot_msht.py b/extras/n3lo_bench/plot_msht.py index 54aa8fcfa..c922c1c03 100644 --- a/extras/n3lo_bench/plot_msht.py +++ b/extras/n3lo_bench/plot_msht.py @@ -14,8 +14,8 @@ n3lo_vars_dict = { - "gg": 17, - "gq": 24, + "gg": 19, + "gq": 21, "qg": 15, "qq": 6, } diff --git a/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggg.py b/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggg.py index 6c8b9f0d5..88eee5b88 100644 --- a/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggg.py +++ b/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggg.py @@ -5,7 +5,7 @@ import numpy as np from .....harmonics import cache as c -from .....harmonics.log_functions import lm11, lm11m1, lm11m2 +from .....harmonics.log_functions import lm11, lm11m1, lm12m1, lm13m1 @nb.njit(cache=True) @@ -161,43 +161,48 @@ def gamma_gg_nf1(n, cache, variation): """ S1 = c.get(c.S1, cache, n) S2 = c.get(c.S2, cache, n) - common = 18143.980574437464 + 1992.766087237516/np.power(-1. + n,3) + 20005.925925925927/np.power(n,7) - 19449.679012345678/np.power(n,6) + 80274.123066115/np.power(n,5) - 11714.245609287387*S1 + 13880.514502193577*lm11(n,S1) + S3 = c.get(c.S3, cache, n) + common = 18143.980574437464 + 1992.766087237516/np.power(-1. + n,3) + 20005.925925925927/np.power(n,7) - 19449.679012345678/np.power(n,6) + 80274.123066115/np.power(n,5) + 4341.13370266389/n - 11714.245609287387*S1 + 13880.514502193577*lm11(n,S1) if variation == 1: - fit = 51906.450933224565/n - 55794.44458990475/(1. + n) - (3244.182054400047*S1)/np.power(n,2) + (5896.657744251454*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10270.11416182055/np.power(-1. + n,2) + 18731.17968740991/(-1. + n) + 297.3210929571657/(1. + n) - 23244.924485271466/(2. + n) - 4050.833138545348*lm13m1(n,S1,S2,S3) elif variation == 2: - fit = 143243.25209661626/n - 140219.52798151976/(2. + n) - (81141.96014226894*S1)/np.power(n,2) + (4359.928069421606*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -11082.13131236475/np.power(-1. + n,2) + 21010.979258355084/(-1. + n) - 21217.46135836648/(1. + n) + 8541.603641080774*lm12m1(n,S1,S2) + 1299.6826595628106*lm13m1(n,S1,S2,S3) elif variation == 3: - fit = -4846.510890091015/n + 73944.02374603187/np.power(1. + n,3) + (15528.258395929412*S1)/np.power(n,2) + (5875.765469829209*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -2710.665352609663/np.power(-1. + n,2) + 22945.993521464054/(-1. + n) - 126229.56225118619/np.power(n,4) - 34046.95702168874/(1. + n) - 9872.686392323958*lm13m1(n,S1,S2,S3) elif variation == 4: - fit = 3769.9068671191385/n - (15787.280088316747*S1)/np.power(n,2) + (3319.747916876306*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n - 209289.30375366632*lm11m2(n,S1) + fit = -11295.981203099282/np.power(-1. + n,2) + 29362.42506506866/(-1. + n) - 31878.254277368906/np.power(n,3) - 35458.54478982031/(1. + n) - 5668.488002948361*lm13m1(n,S1,S2,S3) elif variation == 5: - fit = -4404.650816024677/n + (32166.525125055265*S1)/np.power(n,2) + (5984.665222488821*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 26795.61010300351*lm11m1(n,S1) + fit = -10686.93631688797/np.power(-1. + n,2) + 19906.339608012637/(-1. + n) - 22367.39965022059/(1. + n) - 11221.684701529948*lm11m1(n,S1) - 2145.948106277924*lm13m1(n,S1,S2,S3) elif variation == 6: - fit = 18002.20882549217/(-1. + n) - 34510.86180174593/n + (14377.94953322174*S1)/np.power(n,2) + (12777.152485988116*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10281.335740623817/np.power(-1. + n,2) + 18762.685118697587/(-1. + n) - 22923.693890952152/(2. + n) + 118.0397215654495*lm12m1(n,S1,S2) - 3976.892293061728*lm13m1(n,S1,S2,S3) elif variation == 7: - fit = 32712.59210667494/np.power(n,3) - 10863.21459339799/n + (19949.446087845266*S1)/np.power(n,2) + (9104.304296741177*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10204.671424181955/np.power(-1. + n,2) + 18767.66765933924/(-1. + n) - 1092.779160652895/np.power(n,4) - 23043.691361939706/(2. + n) - 4101.2333760090105*lm13m1(n,S1,S2,S3) elif variation == 8: - fit = 23133.58893729803/np.power(n,2) - 6436.943948938613/n + (9529.55663925907*S1)/np.power(n,2) + (6913.820202625404*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10278.644563822769/np.power(-1. + n,2) + 18819.581783601687/(-1. + n) - 265.07755215895946/np.power(n,3) - 23051.635742762955/(2. + n) - 4064.284439480962*lm13m1(n,S1,S2,S3) elif variation == 9: - fit = 3314.1531443520435/(-1. + n) + 35997.28048068957/n - 45522.85315535845/(1. + n) + (7163.336378194301*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10347.501508088137/np.power(-1. + n,2) + 19058.23126571671/(-1. + n) - 572.2668461573236/np.power(n,2) - 23256.742273946194/(2. + n) - 4035.759520905052*lm13m1(n,S1,S2,S3) elif variation == 10: - fit = 15292.461183783358/(-1. + n) - 7754.767835203314/n - 21106.273066417427/(2. + n) + (11510.166071508424*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10275.582132070176/np.power(-1. + n,2) + 18746.595709341593/(-1. + n) - 22939.992144309395/(2. + n) - 147.20867721931182*lm11m1(n,S1) - 4025.8444124078146*lm13m1(n,S1,S2,S3) elif variation == 11: - fit = 18943.68531934485/(-1. + n) - 34231.50197430196/n + 38795.17200645132/np.power(1. + n,2) + (12574.453319273369*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -24926.888750623133/np.power(-1. + n,2) + 17810.84642127126/(-1. + n) + 208758.85768476047/np.power(n,4) + 22667.73532614404*lm12m1(n,S1,S2) + 19776.5826765651*lm13m1(n,S1,S2,S3) elif variation == 12: - fit = 243015.55817041075/(-1. + n) - 405291.74871837825/n - 924241.7199143948/np.power(1. + n,3) + (99039.0230533651*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -10763.5212982461/np.power(-1. + n,2) + 8568.352997277027/(-1. + n) + 47494.674935205614/np.power(n,3) + 21267.541668576003*lm12m1(n,S1,S2) + 11681.399225017101*lm13m1(n,S1,S2,S3) elif variation == 13: - fit = 9421.639301348665/(-1. + n) - 16264.723220366097/n + (8269.376900788462*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n - 99755.61548732712*lm11m2(n,S1) + fit = -5727.151193148642/np.power(-1. + n,2) - 1579.7328323989361/(-1. + n) + 39389.08181155469/np.power(n,2) + 8242.704431969565*lm12m1(n,S1,S2) + 74.93434922328093*lm13m1(n,S1,S2,S3) elif variation == 14: - fit = 32552.831422747156/(-1. + n) - 58844.770942175055/n + (18267.307590060325*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n - 21658.053945007472*lm11m1(n,S1) + fit = -18373.856968226213/np.power(-1. + n,2) + 41392.63735393215/(-1. + n) + 207050.815868518*lm11m1(n,S1) + 166142.36054620336*lm12m1(n,S1,S2) + 64874.865907564*lm13m1(n,S1,S2,S3) elif variation == 15: - fit = 26670.108040113628/(-1. + n) - 192284.97382369108/np.power(n,4) - 17027.576353111184/n - (2060.8605568773337*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 5243.900655452294/np.power(-1. + n,2) - 12659.834824913609/(-1. + n) - 119288.31030415706/np.power(n,4) + 61896.66336205812/np.power(n,2) - 11182.917725840534*lm13m1(n,S1,S2,S3) elif variation == 16: - fit = 64459.179128132346/(-1. + n) - 84418.96962498086/np.power(n,3) - 95536.59785086475/n + (22255.40045589177*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -25962.210430671832/np.power(-1. + n,2) + 14085.129803728569/(-1. + n) + 241740.93047797284/np.power(n,4) - 32712.217132272293*lm11m1(n,S1) + 12651.448553539236*lm13m1(n,S1,S2,S3) elif variation == 17: - fit = -35383.49147569926/(-1. + n) + 68602.85078732096/np.power(n,2) + 48742.57555689275/n - (4610.608264940457*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -2539.909047069818/np.power(-1. + n,2) - 8001.899230702169/(-1. + n) - 30056.772339779138/np.power(n,3) + 64316.26925516245/np.power(n,2) - 7270.160083308018*lm13m1(n,S1,S2,S3) + elif variation == 18: + fit = -9646.328315869272/np.power(-1. + n,2) + 3749.766574153606/(-1. + n) + 54466.866417785626/np.power(n,3) - 30394.942945299434*lm11m1(n,S1) + 3872.6283293477754*lm13m1(n,S1,S2,S3) + elif variation == 19: + fit = -5066.965729118176/np.power(-1. + n,2) - 3822.9837355590003/(-1. + n) + 41445.27729170122/np.power(n,2) - 10808.501548399454*lm11m1(n,S1) - 3307.7625874988926*lm13m1(n,S1,S2,S3) else: - fit = 23311.07841529563/(-1. + n) - 11310.8808131583/np.power(n,4) - 3041.5516187238777/np.power(n,3) + 5396.261160271705/np.power(n,2) - 24256.141353532745/n - 50017.51153931546/np.power(1. + n,3) + 2282.06894155596/np.power(1. + n,2) - 5959.841043839012/(1. + n) - 9489.753002819834/(2. + n) - (507.1580296279411*S1)/np.power(n,2) + (13331.74331502859*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 302.2091857644728*lm11m1(n,S1) - 18179.112896529026*lm11m2(n,S1) + fit = -10273.4997259521/np.power(-1. + n,2) + 13981.787431778737/(-1. + n) + 10731.007181407218/np.power(n,4) + 2092.707220193907/np.power(n,3) + 10867.106572332586/np.power(n,2) - 5936.475880375734/(1. + n) - 7287.404205220098/(2. + n) + 6408.750571778819*lm11m1(n,S1) + 11946.315017659957*lm12m1(n,S1,S2) + 2659.4069274848257*lm13m1(n,S1,S2,S3) return common + fit @@ -223,43 +228,48 @@ def gamma_gg_nf2(n, cache, variation): """ S1 = c.get(c.S1, cache, n) S2 = c.get(c.S2, cache, n) - common = -423.811346198137 - 568.8888888888889/np.power(n,7) + 1725.6296296296296/np.power(n,6) - 2196.543209876543/np.power(n,5) + 440.0487580115612*S1 - 135.11111111111114*lm11(n,S1) + S3 = c.get(c.S3, cache, n) + common = -423.811346198137 - 568.8888888888889/np.power(n,7) + 1725.6296296296296/np.power(n,6) - 2196.543209876543/np.power(n,5) + 21.333333333333336/n + 440.0487580115612*S1 - 135.11111111111114*lm11(n,S1) if variation == 1: - fit = -2376.754718471023/n + 1986.9752104021475/(1. + n) - (29.413328132453657*S1)/np.power(n,2) + (243.6914020341996*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -16.959956452231857/np.power(-1. + n,2) - 629.5045317989062/(-1. + n) - 682.6697400582308/(1. + n) + 1217.639625778457/(2. + n) - 72.64979891934051*lm13m1(n,S1,S2,S3) elif variation == 2: - fit = -5629.479269151885/n + 4993.556762890926/(2. + n) + (2744.7150845388774*S1)/np.power(n,2) + (298.41806508138217*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 25.57596402110471/np.power(-1. + n,2) - 748.9273459351353/(-1. + n) + 444.33979999567083/(1. + n) - 447.4350978280687*lm12m1(n,S1,S2) - 352.92603979329243*lm13m1(n,S1,S2,S3) elif variation == 3: - fit = -355.6443895005434/n - 2633.32565133846/np.power(1. + n,3) - (697.9453672577569*S1)/np.power(n,2) + (244.43542649166247*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -412.9468061824264/np.power(-1. + n,2) - 850.2892602188854/(-1. + n) + 6612.287213025851/np.power(n,4) + 1116.3876833223574/(1. + n) + 232.31652703107594*lm13m1(n,S1,S2,S3) elif variation == 4: - fit = -662.4958800366925/n + (417.27675074971785*S1)/np.power(n,2) + (335.4613978477791*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 7453.298646800853*lm11m2(n,S1) + fit = 36.77806971484529/np.power(-1. + n,2) - 1186.401399819004/(-1. + n) + 1669.8796175207788/np.power(n,3) + 1190.3309307108536/(1. + n) + 12.087867790598803*lm13m1(n,S1,S2,S3) elif variation == 5: - fit = -371.3800961661366/n - (1290.4743148587395*S1)/np.power(n,2) + (240.55724273082328*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n - 954.2565288285368*lm11m1(n,S1) + fit = 4.874451882150377/np.power(-1. + n,2) - 691.0629716579465/(-1. + n) + 504.5770544662291/(1. + n) + 587.8258700832249*lm11m1(n,S1) - 172.43345273623754*lm13m1(n,S1,S2,S3) elif variation == 6: - fit = -641.1022267836108/(-1. + n) + 700.7749426995084/n - (656.9800845794034*S1)/np.power(n,2) - (1.339668489438944*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 8.805562596792123/np.power(-1. + n,2) - 701.843175427027/(-1. + n) + 480.0720211823408/(2. + n) - 271.02734366604454*lm12m1(n,S1,S2) - 242.4230809561374*lm13m1(n,S1,S2,S3) elif variation == 7: - fit = -1164.9745787725433/np.power(n,3) - 141.37500847741444/n - (855.3945615089527*S1)/np.power(n,2) + (129.45934487552083*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -167.2209966272019/np.power(-1. + n,2) - 713.2834324613012/(-1. + n) + 2509.096338027503/np.power(n,4) + 755.5944925816235/(2. + n) + 43.07262314317838*lm13m1(n,S1,S2,S3) elif variation == 8: - fit = -823.8430919763521/np.power(n,2) - 299.005218970897/n - (484.3170791242564*S1)/np.power(n,2) + (207.4677850666592*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 2.6264350142567814/np.power(-1. + n,2) - 832.4818430533794/(-1. + n) + 608.6363460583859/np.power(n,3) + 773.8353390059995/(2. + n) - 41.76468402930814*lm13m1(n,S1,S2,S3) elif variation == 9: - fit = 30.047719973994777/(-1. + n) - 2520.994974716468/n + 2080.1024406993206/(1. + n) + (255.17572494624633*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 160.72672912659135/np.power(-1. + n,2) - 1380.437517169532/(-1. + n) + 1313.9641564742117/np.power(n,2) + 1244.7740838194043/(2. + n) - 107.25986487346194*lm13m1(n,S1,S2,S3) elif variation == 10: - fit = -517.28413779068/(-1. + n) - 521.8069586029795/n + 964.421319764148/(2. + n) + (56.55348517779473*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -4.4051195549716065/np.power(-1. + n,2) - 664.9007816190623/(-1. + n) + 517.4939352213107/(2. + n) + 338.0012780657685*lm11m1(n,S1) - 130.02563798413794*lm13m1(n,S1,S2,S3) elif variation == 11: - fit = -684.1216646478402/(-1. + n) + 688.0099901838175/n - 1772.6905583568107/np.power(1. + n,2) + (7.922383473211929*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 315.51530441621395/np.power(-1. + n,2) - 681.9096023524954/(-1. + n) - 4371.86464036536/np.power(n,4) - 743.2670270884392*lm12m1(n,S1,S2) - 739.8725231366963*lm13m1(n,S1,S2,S3) elif variation == 12: - fit = -10922.769229617297/(-1. + n) + 17643.083571901912/n + 42231.91922591065/np.power(1. + n,3) - (3942.953936253496*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 18.90357718091744/np.power(-1. + n,2) - 488.3516827637743/(-1. + n) - 994.6418190719808/np.power(n,3) - 713.9439257405169*lm12m1(n,S1,S2) - 570.3417703743911*lm13m1(n,S1,S2,S3) elif variation == 13: - fit = -249.02522869092658/(-1. + n) - 132.95657379723917/n + (204.6367663552972*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 4558.191872124068*lm11m2(n,S1) + fit = -86.56896957695098/np.power(-1. + n,2) - 275.828688059755/(-1. + n) - 824.8930651290783/np.power(n,2) - 441.1754981260873*lm12m1(n,S1,S2) - 327.27714570223736*lm13m1(n,S1,S2,S3) elif variation == 14: - fit = -1305.9723629973262/(-1. + n) + 1812.678531475261/n - (252.20454712133116*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 989.6341672183413*lm11m1(n,S1) + fit = 178.2805625979371/np.power(-1. + n,2) - 1175.763607295771/(-1. + n) - 4336.094528843359*lm11m1(n,S1) - 3747.9378120594934*lm12m1(n,S1,S2) - 1684.3286865084197*lm13m1(n,S1,S2,S3) elif variation == 15: - fit = -1037.169631665525/(-1. + n) + 8786.190136094137/np.power(n,4) - 98.09907798298099/n + (676.6623679879976*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -673.7742132225945/np.power(-1. + n,2) + 317.2132626956936/(-1. + n) + 6384.686015786331/np.power(n,4) - 2029.5697078635478/np.power(n,2) + 275.27854922027643*lm13m1(n,S1,S2,S3) elif variation == 16: - fit = -2763.8878304060045/(-1. + n) + 3857.4055136430484/np.power(n,3) + 3489.2597080989826/n - (434.43481453536947*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = 349.4631362634346/np.power(-1. + n,2) - 559.7446717031943/(-1. + n) - 5453.335146329048/np.power(n,4) + 1072.6220342502565*lm11m1(n,S1) - 506.2418943583583*lm13m1(n,S1,S2,S3) elif variation == 17: - fit = 1798.2819022378217/(-1. + n) - 3134.710315160434/np.power(n,2) - 3103.373221197692/n + (793.169486129463*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -257.1602061122679/np.power(-1. + n,2) + 67.90588148648591/(-1. + n) + 1608.7331067743435/np.power(n,3) - 2159.0746347923864/np.power(n,2) + 65.85543860914298*lm13m1(n,S1,S2,S3) + elif variation == 18: + fit = -18.600199987013553/np.power(-1. + n,2) - 326.59342404939514/(-1. + n) - 1228.6958454214596/np.power(n,3) + 1020.3475901067098*lm11m1(n,S1) - 308.20406610462027*lm13m1(n,S1,S2,S3) + elif variation == 19: + fit = -121.90417458800518/np.power(-1. + n,2) - 155.76283554846327/(-1. + n) - 934.9471223483207/np.power(n,2) + 578.5050396951302*lm11m1(n,S1) - 146.22455326916472*lm13m1(n,S1,S2,S3) else: - fit = -958.4119229639646/(-1. + n) + 516.8347138878904/np.power(n,4) + 158.3782902865003/np.power(n,3) - 232.85608277275213/np.power(n,2) + 477.6730210169136/n + 2329.329033798364/np.power(1. + n,3) - 104.27591519745945/np.power(1. + n,2) + 239.23986182949812/(1. + n) + 350.46929897971023/(2. + n) - (50.14899412782161*S1)/np.power(n,2) - (55.13659342362342*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 2.0810375523414395*lm11m1(n,S1) + 706.5582658191131*lm11m2(n,S1) + fit = -34.631097341548454/np.power(-1. + n,2) - 614.62987509215/(-1. + n) + 298.9931463234356/np.power(n,4) + 87.57428451895092/np.power(n,3) - 243.92212492942747/np.power(n,2) + 135.41924886509895/(1. + n) + 262.60049987311237/(2. + n) - 38.88382719169835*lm11m1(n,S1) - 334.9887739215079*lm12m1(n,S1,S2) - 251.2295891027122*lm13m1(n,S1,S2,S3) return common + fit @@ -284,43 +294,48 @@ def gamma_gg_nf0(n, cache, variation): """ S1 = c.get(c.S1, cache, n) S2 = c.get(c.S2, cache, n) - common = -68587.9129845144 - 49851.703887834694/np.power(-1. + n,4) + 213823.9810748423/np.power(-1. + n,3) - 103680./np.power(n,7) - 17280./np.power(n,6) - 627978.8224813186/np.power(n,5) + 40880.33011934297*S1 - 85814.12027987762*lm11(n,S1) + S3 = c.get(c.S3, cache, n) + common = -68587.9129845144 - 49851.703887834694/np.power(-1. + n,4) + 213823.9810748423/np.power(-1. + n,3) - 103680./np.power(n,7) - 17280./np.power(n,6) - 627978.8224813186/np.power(n,5) - 54482.80778086425/n + 40880.33011934297*S1 - 85814.12027987762*lm11(n,S1) if variation == 1: - fit = 657693.1275908262/n - 1.1706414373839432e6/(1. + n) - (370650.30059459625*S1)/np.power(n,2) + (287643.02359540213*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -295448.0379235009/np.power(-1. + n,2) + 224578.11757296775/(-1. + n) - 526757.6738519811/(1. + n) + 296021.5646034255/(2. + n) + 2224.0922337045213*lm13m1(n,S1,S2,S3) elif variation == 2: - fit = 2.5740603391615152e6/n - 2.941991644365525e6/(2. + n) - (2.0050489863420033e6*S1)/np.power(n,2) + (255400.3971361596*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -285107.088545888/np.power(-1. + n,2) + 195545.1200082606/(-1. + n) - 252769.2783475656/(1. + n) - 108776.38581520668*lm12m1(n,S1,S2) - 65914.13979179235*lm13m1(n,S1,S2,S3) elif variation == 3: - fit = -533059.2724548094/n + 1.5514436765207502e6/np.power(1. + n,3) + (23220.39448094448*S1)/np.power(n,2) + (287204.67597244744*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -391716.7896443467/np.power(-1. + n,2) + 170902.9255344149/(-1. + n) + 1.607519634683242e6/np.power(n,4) - 89387.05777989682/(1. + n) + 76364.75507676331*lm13m1(n,S1,S2,S3) elif variation == 4: - fit = -352275.4015418936/n - (633821.1309449758*S1)/np.power(n,2) + (233576.03813655287*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n - 4.3911671345781535e6*lm11m2(n,S1) + fit = -282383.73363518645/np.power(-1. + n,2) + 89190.37336362494/(-1. + n) + 405966.0728943653/np.power(n,3) - 71410.64232788606/(1. + n) + 22824.74956225227*lm13m1(n,S1,S2,S3) elif variation == 5: - fit = -523788.46214332484/n + (372313.29472429893*S1)/np.power(n,2) + (289489.537196911*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 562207.434039533*lm11m1(n,S1) + fit = -290139.8534816189/np.power(-1. + n,2) + 209612.58483575174/(-1. + n) - 238124.94028671857/(1. + n) + 142906.92425938678*lm11m1(n,S1) - 22034.409788754692*lm13m1(n,S1,S2,S3) elif variation == 6: - fit = 377710.2141700686/(-1. + n) - 1.1554566929419546e6/n - (914.6109012422813*S1)/np.power(n,2) + (432004.92760893324*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -275566.9972336391/np.power(-1. + n,2) + 168760.59203878703/(-1. + n) - 273096.0817605587/(2. + n) - 209128.55034080063*lm12m1(n,S1,S2) - 128775.38508377109*lm13m1(n,S1,S2,S3) elif variation == 7: - fit = 686353.5630791902/np.power(n,3) - 659297.6949952773/n + (115982.7752636412*S1)/np.power(n,2) + (354943.7019770036*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -411391.59210307786/np.power(-1. + n,2) + 159933.1271168039/(-1. + n) + 1.9360543948787057e6/np.power(n,4) - 60499.02697383511/(2. + n) + 91517.15779852161*lm13m1(n,S1,S2,S3) elif variation == 8: - fit = 485373.3737194109/np.power(n,2) - 566428.6671276395/n - (102640.3233464204*S1)/np.power(n,2) + (308984.44084716233*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -280334.89989693864/np.power(-1. + n,2) + 67957.93940012196/(-1. + n) + 469632.45484412194/np.power(n,3) - 46424.130625098995/(2. + n) + 26055.48583672462*lm13m1(n,S1,S2,S3) elif variation == 9: - fit = 378644.55156064907/(-1. + n) - 1.1599418606928566e6/n + 2895.802190713511/(1. + n) + (432362.03398212773*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -158342.46596423967/np.power(-1. + n,2) - 354852.44655132474/(-1. + n) + 1.0138734178112751e6/np.power(n,2) + 316958.89807541796/(2. + n) - 24481.5265510284*lm13m1(n,S1,S2,S3) elif variation == 10: - fit = 377882.58678340475/(-1. + n) - 1.1571587030349977e6/n + 1342.6133808775278/(2. + n) + (432085.52321715665*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -285760.5473383797/np.power(-1. + n,2) + 197265.86814370425/(-1. + n) - 244220.80103026525/(2. + n) + 260806.5899887168*lm11m1(n,S1) - 42047.920641263154*lm13m1(n,S1,S2,S3) elif variation == 11: - fit = 377650.3249167252/(-1. + n) - 1.1554744635946492e6/n - 2467.8405744727033/np.power(1. + n,2) + (432017.82171933743*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -450043.3779284024/np.power(-1. + n,2) + 157421.08366934053/(-1. + n) + 2.4869999720694227e6/np.power(n,4) + 59511.9900450049*lm12m1(n,S1,S2) + 154206.10006698*lm13m1(n,S1,S2,S3) elif variation == 12: - fit = 363396.65285306936/(-1. + n) - 1.1318705591614237e6/n + 58792.91414672283/np.power(1. + n,3) + (426517.6328449669*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -281311.4024370307/np.power(-1. + n,2) + 47312.79345234101/(-1. + n) + 565816.73490305/np.power(n,3) + 42831.109406509524*lm12m1(n,S1,S2) + 57766.0196738513*lm13m1(n,S1,S2,S3) elif variation == 13: - fit = 378256.0418217043/(-1. + n) - 1.1566173672939881e6/n + (432291.67647271376*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 6345.659593752382*lm11m2(n,S1) + fit = -221311.7815844328/np.power(-1. + n,2) - 73584.06072125914/(-1. + n) + 469252.6413087417/np.power(n,2) - 112337.25184482028*lm12m1(n,S1,S2) - 80504.89319687682*lm13m1(n,S1,S2,S3) elif variation == 14: - fit = 376784.61918064323/(-1. + n) - 1.1539087630012901e6/n + (431655.6875663606*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 1377.713295886333*lm11m1(n,S1) + fit = -371975.3618425755/np.power(-1. + n,2) + 438357.2510794566/(-1. + n) + 2.4666516141772955e6*lm11m1(n,S1) + 1.7687634818009005e6*lm12m1(n,S1,S2) + 691473.981199157*lm13m1(n,S1,S2,S3) elif variation == 15: - fit = 377158.8312978629/(-1. + n) + 12231.642128156545/np.power(n,4) - 1.1565688406394941e6/n + (432948.8040951983*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -370832.83073654736/np.power(-1. + n,2) + 77423.19888297348/(-1. + n) + 1.6257432335929913e6/np.power(n,4) + 162503.82143718746/np.power(n,2) + 72924.86692930982*lm13m1(n,S1,S2,S3) elif variation == 16: - fit = 374754.9908692327/(-1. + n) + 5370.064049746925/np.power(n,3) - 1.1515747205286513e6/n + (431401.9967878436*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -452761.5168438991/np.power(-1. + n,2) + 147639.56791297536/(-1. + n) + 2.573591277265509e6/np.power(n,4) - 85882.82474255121*lm11m1(n,S1) + 135499.7359376153*lm13m1(n,S1,S2,S3) elif variation == 17: - fit = 381106.18821765727/(-1. + n) - 4363.968245037315/np.power(n,2) - 1.1607526150905455e6/n + (433110.99878386786*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + fit = -264749.7122550716/np.power(-1. + n,2) + 13941.645196000183/(-1. + n) + 409634.3902470049/np.power(n,3) + 129527.76620894097/np.power(n,2) + 19599.111490094336*lm13m1(n,S1,S2,S3) + elif variation == 18: + fit = -279061.4660973225/np.power(-1. + n,2) + 37608.549986420694/(-1. + n) + 579858.1648363634/np.power(n,3) - 61212.957613155806*lm11m1(n,S1) + 42039.78644131242*lm13m1(n,S1,S2,S3) + elif variation == 19: + fit = -230309.24368551886/np.power(-1. + n,2) - 43011.492732260434/(-1. + n) + 441229.3934290683/np.power(n,2) + 147305.70173040565*lm11m1(n,S1) - 34403.17005106444*lm13m1(n,S1,S2,S3) else: - fit = 221373.2353924128/(-1. + n) + 719.5083604797968/np.power(n,4) + 40689.6251252316/np.power(n,3) + 28294.67091025727/np.power(n,2) - 643671.8010288504/n + 94719.79945102782/np.power(1. + n,3) - 145.16709261604137/np.power(1. + n,2) - 68690.9197172488/(1. + n) - 172979.3547638028/(2. + n) - (153032.87574472665*S1)/np.power(n,2) + (372566.99517294974*((-1. + 2.*n - 2.*np.power(n,2))/(np.power(-1. + n,2)*np.power(n,2)) + S2))/n + 33152.06749031878*lm11m1(n,S1) - 257930.6749990824*lm11m2(n,S1) + fit = -309397.2999567167/np.power(-1. + n,2) + 101684.3546415316/(-1. + n) + 538416.2374994669/np.power(n,4) + 127942.51672236343/np.power(n,3) + 116651.94948395861/np.power(n,2) - 62023.66276810779/(1. + n) - 592.6093532060254/(2. + n) + 151082.8972526367*lm11m1(n,S1) + 75834.96806587302*lm12m1(n,S1,S2) + 52333.389323249234*lm13m1(n,S1,S2,S3) return common + fit diff --git a/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggq.py b/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggq.py index 688472289..129a3c702 100644 --- a/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggq.py +++ b/src/ekore/anomalous_dimensions/unpolarized/space_like/as4/ggq.py @@ -92,59 +92,51 @@ def gamma_gq_nf0(n, cache, variation): S3 = c.get(c.S3, cache, n) S4 = c.get(c.S4, cache, n) S5 = c.get(c.S5, cache, n) - S2m2 = ((-1 + 2 * n - 2 * n**2)/((-1 + n)**2 * n**2) + S2)/n - S1m2 = ((1 - 2 * n)/((-1 + n) * n) + S1)/n common = -22156.31283903764/np.power(-1. + n,4) + 95032.88047770769/np.power(-1. + n,3) - 37609.87654320987/np.power(n,7) - 35065.67901234568/np.power(n,6) - 175454.58483973087/np.power(n,5) - 375.3983146907502*lm14(n,S1,S2,S3,S4) - 13.443072702331962*lm15(n,S1,S2,S3,S4,S5) if variation == 1: - fit = 54395.612515252/(-1. + n) - 2.1646239683351885e6/np.power(n,4) + (2855.303350475541*np.power(S1,3))/n - 60918.73535555526*S2m2 + fit = -134611.31548520518/np.power(-1. + n,2) + 105578.6478973615/(-1. + n) - 271004.1457372756/(1. + n) + 135827.42962246042/(2. + n) - 1659.6381024386487*lm13(n,S1,S2,S3) elif variation == 2: - fit = -226090.67195519924/(-1. + n) + 1.1897625270895162e6/np.power(n,3) + (767.5822028088761*np.power(S1,3))/n + 166822.85829328437*S2m2 + fit = -129784.96381286802/np.power(-1. + n,2) + 92404.11351667382/(-1. + n) - 166871.00811514194/(1. + n) + 8603.419512104943*lm12(n,S1,S2) - 333.06211910306587*lm13(n,S1,S2,S3) elif variation == 3: - fit = -156969.41163838003/(-1. + n) + 308065.6508918336/np.power(n,2) + (2298.0372229048253*np.power(S1,3))/n + 79897.51027543494*S2m2 + fit = -130354.69780717866/np.power(-1. + n,2) + 93906.9798287439/(-1. + n) - 206720.3072485826/(1. + n) - 30775.363703337393*lm11(n,S1) - 1101.8494545818282*lm13(n,S1,S2,S3) elif variation == 4: - fit = 166341.6709608748/(-1. + n) - 491341.2274352182/n + (1928.2261659049982*np.power(S1,3))/n + 192393.6054838923*S2m2 + fit = -156517.8307292757/np.power(-1. + n,2) + 89433.22729993386/(-1. + n) + 384766.5696200253/np.power(n,4) - 128852.37353471664/(1. + n) - 1762.2085163661038*lm13(n,S1,S2,S3) elif variation == 5: - fit = -2910.286549470067/(-1. + n) - 231374.96742185086/(1. + n) + (2346.7938301139043*np.power(S1,3))/n + 124908.19081096651*S2m2 + fit = -129351.9314649959/np.power(-1. + n,2) + 54671.293834508826/(-1. + n) + 148449.9518256113/np.power(n,3) - 88593.14563810707/(1. + n) - 1703.1788616091594*lm13(n,S1,S2,S3) elif variation == 6: - fit = -31627.458190721398/(-1. + n) - 195967.18171506765/(2. + n) + (2692.8548253146964*np.power(S1,3))/n + 109472.35691430997*S2m2 + fit = -289524.23824347754/np.power(-1. + n,2) + 762852.3222214412/(-1. + n) - 1.1600176710948618e6/np.power(n,2) - 809182.8193866021/(1. + n) - 1836.245183321374*lm13(n,S1,S2,S3) elif variation == 7: - fit = -162008.96605774807/(-1. + n) + 720879.4649423409/np.power(1. + n,2) + (3458.480965363866*np.power(S1,3))/n + 46219.18000891417*S2m2 + fit = -122050.84394025133/np.power(-1. + n,2) + 71292.218842658/(-1. + n) - 217660.39733703827/(2. + n) + 22390.205543958295*lm12(n,S1,S2) + 1792.7460216611355*lm13(n,S1,S2,S3) elif variation == 8: - fit = -127936.1111804959/(-1. + n) + 1.317743273735378e6/np.power(1. + n,3) + (1810.811048345219*np.power(S1,3))/n + 80332.05372142064*S2m2 + fit = -116666.509065989/np.power(-1. + n,2) + 56373.894282328176/(-1. + n) - 436786.1136556859/(2. + n) - 129741.02583569557*lm11(n,S1) + 691.8555166149675*lm13(n,S1,S2,S3) elif variation == 9: - fit = -31133.856975192168/(-1. + n) + (4363.35894123817*np.power(S1,3))/n + 108577.87074947657*S2m2 + 69739.16311988933*lm11(n,S1) + fit = -176374.82189677586/np.power(-1. + n,2) + 74798.33577898303/(-1. + n) + 733535.2482241682/np.power(n,4) - 123119.72215889738/(2. + n) - 1855.182674086565*lm13(n,S1,S2,S3) elif variation == 10: - fit = -43609.29566283978/(-1. + n) + (7720.209697473076*np.power(S1,3))/n + 101242.36850860748*S2m2 - 25996.353887666173*lm12(n,S1,S2) + fit = -126797.5604335579/np.power(-1. + n,2) + 29946.67399201152/(-1. + n) + 220548.93815270695/np.power(n,3) - 65968.49558222751/(2. + n) - 1724.3256828880108*lm13(n,S1,S2,S3) elif variation == 11: - fit = -36336.05360209993/(-1. + n) + (16069.407610813529*np.power(S1,3))/n + 106190.63289422497*S2m2 + 11885.534727629803*lm13(n,S1,S2,S3) + fit = -56603.682794921304/np.power(-1. + n,2) - 225396.73137215254/(-1. + n) + 584136.1120157596/np.power(n,2) + 204224.41065290783/(2. + n) - 1570.7062041132795*lm13(n,S1,S2,S3) elif variation == 12: - fit = -56096.82600570976/(-1. + n) - (30904.014914347616*np.power(S1,2))/n + (8763.722478566568*np.power(S1,3))/n + 94447.37306501447*S2m2 + fit = -127399.17314512776/np.power(-1. + n,2) + 86110.78284306003/(-1. + n) + 128873.43260633861*lm11(n,S1) + 44630.68519659024*lm12(n,S1,S2) + 2886.2747447077363*lm13(n,S1,S2,S3) elif variation == 13: - fit = -1.744831439637831e6/np.power(n,4) + 230734.49573806854/np.power(n,3) + (2450.4248345695696*np.power(S1,3))/n - 16752.071359429487*S2m2 + fit = -247120.59412629303/np.power(-1. + n,2) + 79364.32964611659/(-1. + n) + 1.6888135534086183e6/np.power(n,4) - 29158.622788111865*lm12(n,S1,S2) - 6605.8570968113345*lm13(n,S1,S2,S3) elif variation == 14: - fit = -1.607549555980178e6/np.power(n,4) + 79281.89558453669/np.power(n,2) + (2711.8887412487193*np.power(S1,3))/n - 24679.125874904974*S2m2 + fit = -128861.83507443611/np.power(-1. + n,2) + 11966.126835094941/(-1. + n) + 316462.3091625236/np.power(n,3) - 9737.159060072763*lm12(n,S1,S2) - 3253.8465506459015*lm13(n,S1,S2,S3) elif variation == 15: - fit = -3.2164345301161744e6/np.power(n,4) + 238747.19120481954/n + (3305.7786240482187*np.power(S1,3))/n - 184005.5159797561*S2m2 + fit = -88285.0983393474/np.power(-1. + n,2) - 81776.66054398555/(-1. + n) + 301369.70052571065/np.power(n,2) + 10838.566464150015*lm12(n,S1,S2) + 57.46109548925452*lm13(n,S1,S2,S3) elif variation == 16: - fit = -109930.67245290388/np.power(n,4) - 219624.56359674424/(1. + n) + (2372.618543477443*np.power(S1,3))/n + 115470.94939990941*S2m2 + fit = -199811.41276401555/np.power(-1. + n,2) + 82030.26173438856/(-1. + n) + 1.021461077715438e6/np.power(n,4) + 50925.69521801989*lm11(n,S1) - 2854.941152739061*lm13(n,S1,S2,S3) elif variation == 17: - fit = -795851.0838465183/np.power(n,4) - 123917.39558697924/(2. + n) + (2752.5810580044063*np.power(S1,3))/n + 46825.94005648564*S2m2 + fit = -128599.87560093393/np.power(-1. + n,2) + 25245.26855710262/(-1. + n) + 259784.61882981652/np.power(n,3) + 23080.94295557716*lm11(n,S1) - 2154.164587558643*lm13(n,S1,S2,S3) elif variation == 18: - fit = -1.6205225107818602e6/np.power(n,4) + 181200.78744997882/np.power(1. + n,2) + (3006.918515153242*np.power(S1,3))/n - 33988.47090234153*S2m2 + fit = -75739.554722418/np.power(-1. + n,2) - 135625.28803179998/(-1. + n) + 398031.7522689792/np.power(n,2) - 41335.178649992326*lm11(n,S1) - 849.8594840371891*lm13(n,S1,S2,S3) elif variation == 19: - fit = -1.5188447027408783e6/np.power(n,4) + 393126.6104427561/np.power(1. + n,3) + (2543.6965856722713*np.power(S1,3))/n - 18778.930858748437*S2m2 + fit = -69571.53835633998/np.power(-1. + n,2) - 21824.684729051125/(-1. + n) - 846704.7809898313/np.power(n,4) + 475124.08069442277/np.power(n,3) - 1573.2801259880794*lm13(n,S1,S2,S3) elif variation == 20: - fit = -787951.7251390232/np.power(n,4) + (3814.406780618335*np.power(S1,3))/n + 46878.866608639015*S2m2 + 44353.186297165696*lm11(n,S1) + fit = -131326.8497758187/np.power(-1. + n,2) - 38110.15884910321/(-1. + n) + 457640.10637686535/np.power(n,4) + 219703.5737179606/np.power(n,2) - 1748.1862124636395*lm13(n,S1,S2,S3) elif variation == 21: - fit = -963193.8684382912/np.power(n,4) + (5555.469755339871*np.power(S1,3))/n + 29085.456626461673*S2m2 - 14428.742592292887*lm12(n,S1,S2) - elif variation == 22: - fit = -866884.6931575488/np.power(n,4) + (10777.447027986002*np.power(S1,3))/n + 39266.975234472426*S2m2 + 7125.637269182096*lm13(n,S1,S2,S3) - elif variation == 23: - fit = -1.0989759638298883e6/np.power(n,4) - (15214.098294404646*np.power(S1,2))/n + (5764.027981513135*np.power(S1,3))/n + 15568.25999702346*S2m2 - elif variation == 24: - fit = -1.30410210442889e6/np.power(n,4) + (3218.5602518731034*np.power(S1,3))/n - 20261.445878695344*S1m2 + 8032.736655052195*S2m2 + fit = -109659.49203855239/np.power(-1. + n,2) - 32396.266625595177/(-1. + n) + 166701.1822848159/np.power(n,3) + 142618.77212791165/np.power(n,2) - 1686.818976852953*lm13(n,S1,S2,S3) else: - fit = -27249.23559757206/(-1. + n) - 741654.0341202153/np.power(n,4) + 59187.37595114936/np.power(n,3) + 16139.481103182095/np.power(n,2) - 10524.751509599944/n + 71286.24517408892/np.power(1. + n,3) + 37586.67718301332/np.power(1. + n,2) - 18791.647125774794/(1. + n) - 13328.524054251953/(2. + n) - (1921.5880503646777*np.power(S1,2))/n + (4306.191959951149*np.power(S1,3))/n - 844.2269116123059*S1m2 + 48854.5972905356*S2m2 + 4753.847892377293*lm11(n,S1) - 1684.379019998294*lm12(n,S1,S2) + 792.1321665338291*lm13(n,S1,S2,S3) + fit = -136905.419981799/np.power(-1. + n,2) + 56230.69937898662/(-1. + n) + 163786.27496929924/np.power(n,4) + 75574.81337856653/np.power(n,3) + 23135.3447410219/np.power(n,2) - 79582.08569811552/(1. + n) - 23975.375640880044/(2. + n) + 48.97631385287552*lm11(n,S1) + 2265.099755648517*lm12(n,S1,S2) - 1373.5720765300828*lm13(n,S1,S2,S3) return common + fit @@ -172,60 +164,51 @@ def gamma_gq_nf1(n, cache, variation): S3 = c.get(c.S3, cache, n) S4 = c.get(c.S4, cache, n) S5 = c.get(c.S5, cache, n) - S3m2 = (-(((-1 + 2 * n) * (1 - n + n**2))/((-1 + n)**3 * n**3)) + S3)/n - S2m2 = ((-1 + 2 * n - 2 * n**2)/((-1 + n)**2 * n**2) + S2)/n - S1m2 = ((1 - 2 * n)/((-1 + n) * n) + S1)/n - common = 5309.62962962963/np.power(n,7) + 221.23456790123456/np.power(n,6) + 9092.91243376357/np.power(n,5) + 34.49474165523548*lm14(n,S1,S2,S3,S4) + 0.5486968449931413*lm15(n,S1,S2,S3,S4,S5) + common = 885.6738165500071/np.power(-1. + n,3) + 5309.62962962963/np.power(n,7) + 221.23456790123456/np.power(n,6) + 9092.91243376357/np.power(n,5) + 34.49474165523548*lm14(n,S1,S2,S3,S4) + 0.5486968449931413*lm15(n,S1,S2,S3,S4,S5) if variation == 1: - fit = 61414.641491730144/np.power(n,4) - (275.8821081210985*np.power(S1,3))/n - 1723.0775384248207*S2m2 + 5359.279437479722*S3m2 + fit = -4488.023094730909/np.power(-1. + n,2) + 11415.451852682689/(-1. + n) - 22278.11557093013/(1. + n) + 16857.05748831136/(2. + n) + 218.39366882799368*lm13(n,S1,S2,S3) elif variation == 2: - fit = 30628.764498540346/np.power(n,3) - (270.06312683778754*np.power(S1,3))/n + 1773.2287929788677*S2m2 + 579.1073675469371*S3m2 + fit = -3889.0418151355752/np.power(-1. + n,2) + 9780.407413909863/(-1. + n) - 9354.523537908572/(1. + n) + 1067.7396878871195*lm12(n,S1,S2) + 383.03027923765*lm13(n,S1,S2,S3) elif variation == 3: - fit = 14964.683461563509/np.power(n,2) - (218.2558990293935*np.power(S1,3))/n + 1752.1522405673672*S2m2 - 1437.7646853596411*S3m2 + fit = -3959.7494676460906/np.power(-1. + n,2) + 9966.92278779446/(-1. + n) - 14300.077821225603/(1. + n) - 3819.420544236109*lm11(n,S1) + 287.618827026041*lm13(n,S1,S2,S3) elif variation == 4: - fit = 7580.473213968261/n - (247.331894047618*np.power(S1,3))/n - 6197.2716578690515*S2m2 + 4215.915142027546*S3m2 + fit = -7206.762511830159/np.power(-1. + n,2) + 9411.701329387806/(-1. + n) + 47752.005627238184/np.power(n,4) - 4636.1664981662325/(1. + n) + 205.6640208549657*lm13(n,S1,S2,S3) elif variation == 5: - fit = 11506.23542429956/(1. + n) - (274.1023835976748*np.power(S1,3))/n - 10030.195812335383*S2m2 + 7245.875500079163*S3m2 + fit = -3835.299716042018/np.power(-1. + n,2) + 5097.521841045809/(-1. + n) + 18423.593665995402/np.power(n,3) + 360.2625808084624/(1. + n) + 212.9899806152177*lm13(n,S1,S2,S3) elif variation == 6: - fit = 15648.586212999671/(2. + n) - (319.57482516808324*np.power(S1,3))/n - 13077.961868048167*S2m2 + 9906.744899797963*S3m2 + fit = -23713.713015219728/np.power(-1. + n,2) + 92987.34159859698/(-1. + n) - 143965.65276583107/np.power(n,2) - 89069.54986300123/(1. + n) + 196.47559437456405*lm13(n,S1,S2,S3) elif variation == 7: - fit = 32890.76649300865/np.power(1. + n,2) - (166.9129330699367*np.power(S1,3))/n - 70.8880877568522*S2m2 - 1177.148738100283*S3m2 + fit = -3455.4793454735536/np.power(-1. + n,2) + 8596.908147688335/(-1. + n) - 12201.695987567426/(2. + n) + 1840.6050040604714*lm12(n,S1,S2) + 502.1997054577737*lm13(n,S1,S2,S3) elif variation == 8: - fit = 102016.12308266855/np.power(1. + n,3) - (240.30275153122795*np.power(S1,3))/n + 4585.802226607708*S2m2 - 3985.368690549865*S3m2 + fit = -3012.8557307127066/np.power(-1. + n,2) + 7370.535179202942/(-1. + n) - 30215.103197366938/(2. + n) - 10665.466242204988*lm11(n,S1) + 411.70010872417294*lm13(n,S1,S2,S3) elif variation == 9: - fit = (-450.823181671801*np.power(S1,3))/n - 12903.050719269673*S2m2 + 9834.061598926022*S3m2 - 5511.504206466589*lm11(n,S1) + fit = -7921.226007375836/np.power(-1. + n,2) + 8885.131333721463/(-1. + n) + 60300.859940087874/np.power(n,4) - 4429.9031168628235/(2. + n) + 202.31876873895882*lm13(n,S1,S2,S3) elif variation == 10: - fit = (-882.1406501674703*np.power(S1,3))/n - 15619.249097143265*S2m2 + 12292.391588412715*S3m2 + 2777.986504535076*lm12(n,S1,S2) + fit = -3845.68702415166/np.power(-1. + n,2) + 5198.064104104413/(-1. + n) + 18130.404314827305/np.power(n,3) + 268.2598106136584/(2. + n) + 213.07597381881035*lm13(n,S1,S2,S3) elif variation == 11: - fit = (-1513.783497714283*np.power(S1,3))/n - 13902.310762445584*S2m2 + 10684.561917950059*S3m2 - 1053.755322341623*lm13(n,S1,S2,S3) + fit = 1924.6576108019278/np.power(-1. + n,2) - 15792.64760438993/(-1. + n) + 48019.38279297407/np.power(n,2) + 22479.68678039739/(2. + n) + 225.7043876490835*lm13(n,S1,S2,S3) elif variation == 12: - fit = (5100.183003924889*np.power(S1,2))/n - (1401.3877591921307*np.power(S1,3))/n - 21387.15682013914*S2m2 + 17430.91515626977*S3m2 + fit = -3755.2981815948488/np.power(-1. + n,2) + 9427.613297165519/(-1. + n) + 7224.439837356762*lm11(n,S1) + 3087.370950732838*lm12(n,S1,S2) + 563.5011879300971*lm13(n,S1,S2,S3) elif variation == 13: - fit = 31147.78863209503/np.power(n,4) + 15094.71171421834/np.power(n,3) - (273.0143514100448*np.power(S1,3))/n + 3003.4769582959475*S3m2 + fit = -10466.690790833369/np.power(-1. + n,2) + 9049.417851827156/(-1. + n) + 94672.20408711508/np.power(n,4) - 1049.1403952794576*lm12(n,S1,S2) + 31.387360972561613*lm13(n,S1,S2,S3) elif variation == 14: - fit = 30964.22640709071/np.power(n,4) + 7419.742457931761/np.power(n,2) - (247.31006171693753*np.power(S1,3))/n + 1989.190320913944*S3m2 + fit = -3837.292685015662/np.power(-1. + n,2) + 5271.181705657407/(-1. + n) + 17740.37415701935/np.power(n,3) + 39.59599839782818*lm12(n,S1,S2) + 219.29574546428225*lm13(n,S1,S2,S3) elif variation == 15: - fit = 85066.31740469787/np.power(n,4) - 2919.3510109124736/n - (286.87721277546535*np.power(S1,3))/n + 5799.605736056626*S3m2 + fit = -1562.6253047002033/np.power(-1. + n,2) + 16.11001314684768/(-1. + n) + 16894.306500710383/np.power(n,2) + 1193.038474115512*lm12(n,S1,S2) + 404.9223900617979*lm13(n,S1,S2,S3) elif variation == 16: - fit = 74153.37781346358/np.power(n,4) - 2386.6442197774195/(1. + n) - (276.25126180951514*np.power(S1,3))/n + 4967.958260585389*S3m2 + fit = -8764.48511413068/np.power(-1. + n,2) + 9145.339290408388/(-1. + n) + 70660.56110839365/np.power(n,4) + 1832.3294758866361*lm11(n,S1) + 166.3470078948553*lm13(n,S1,S2,S3) elif variation == 17: - fit = 70734.17185530512/np.power(n,4) - 2374.6369076942033/(2. + n) - (269.2518389654746*np.power(S1,3))/n + 4669.21202970862*S3m2 + fit = -3838.357938938717/np.power(-1. + n,2) + 5217.182292574578/(-1. + n) + 17970.85305971273/np.power(n,3) - 93.85827782443143*lm11(n,S1) + 214.8239067092436*lm13(n,S1,S2,S3) elif variation == 18: - fit = -2635.0286245103766/np.power(n,4) + 34301.96273361259/np.power(1. + n,2) - (162.23755129655925*np.power(S1,3))/n - 1457.5977471044935*S3m2 + fit = -181.6939552271119/np.power(-1. + n,2) - 5911.194541729347/(-1. + n) + 27534.232647597233/np.power(n,2) - 4549.9059886744935*lm11(n,S1) + 305.05047772799065*lm13(n,S1,S2,S3) elif variation == 19: - fit = 44641.11065487181/np.power(n,4) + 27862.583657909938/np.power(1. + n,3) - (266.1646951326012*np.power(S1,3))/n + 2807.074625599327*S3m2 + fit = -4078.395708944439/np.power(-1. + n,2) + 5408.59148938392/(-1. + n) + 3443.111172846758/np.power(n,4) + 17095.178652601353/np.power(n,3) + 212.46174952689813*lm13(n,S1,S2,S3) elif variation == 20: - fit = 70879.97629826797/np.power(n,4) - (248.919875787699*np.power(S1,3))/n + 4669.617977026223*S3m2 + 849.4429232949681*lm11(n,S1) + fit = -6300.379658737184/np.power(-1. + n,2) + 4822.632787569217/(-1. + n) + 50374.02833779294/np.power(n,4) + 7905.033644756689/np.power(n,2) + 206.16854967191063*lm13(n,S1,S2,S3) elif variation == 21: - fit = 69029.84607075108/np.power(n,4) - (200.7081314711859*np.power(S1,3))/n + 4499.597346756129*S3m2 - 344.4607838774497*lm12(n,S1,S2) - elif variation == 22: - fit = 70103.38136051684/np.power(n,4) - (100.74792356621695*np.power(S1,3))/n + 4605.876127181845*S3m2 + 149.08180946409476*lm13(n,S1,S2,S3) - elif variation == 23: - fit = 66796.13877765737/np.power(n,4) - (446.9068014839647*np.power(S1,2))/n - (177.25895475872284*np.power(S1,3))/n + 4301.494627873232*S3m2 - elif variation == 24: - fit = 60675.73486178171/np.power(n,4) - (248.51519590078777*np.power(S1,3))/n - 682.8975276953039*S1m2 + 4145.5785035058925*S3m2 + fit = -3915.3786995698256/np.power(-1. + n,2) + 5451.580654627375/(-1. + n) + 18349.375335216806/np.power(n,3) - 579.9569091789359/np.power(n,2) + 212.92345341087133*lm13(n,S1,S2,S3) else: - fit = 30540.48679182162/np.power(n,4) + 1905.1448421982786/np.power(n,3) + 932.6844133123028/np.power(n,2) + 194.21342512732446/n + 5411.6127808574365/np.power(1. + n,3) + 2799.6970511092186/np.power(1. + n,2) + 379.9829668550892/(1. + n) + 553.0812210543945/(2. + n) + (193.88650843503848*np.power(S1,2))/n - (375.74241936415484*np.power(S1,3))/n - 28.454063653970994*S1m2 - 3616.665795969917*S2m2 + 4789.568969203283*S3m2 - 194.2525534654842*lm11(n,S1) + 101.3969050274011*lm12(n,S1,S2) - 37.694729703230344*lm13(n,S1,S2,S3) + fit = -5243.037055009921/np.power(-1. + n,2) + 9562.656801160758/(-1. + n) + 15581.084298736878/np.power(n,4) + 5129.037104065377/np.power(n,3) - 2104.412099474839/np.power(n,2) - 6632.29384335349/(1. + n) - 344.8427724987991/(2. + n) - 479.6134161760297*lm11(n,S1) + 294.2480819006815*lm12(n,S1,S2) + 266.47872117598763*lm13(n,S1,S2,S3) return common + fit diff --git a/tests/ekore/anomalous_dimensions/unpolarized/space_like/test_as4.py b/tests/ekore/anomalous_dimensions/unpolarized/space_like/test_as4.py index ad72659cb..13562cd61 100644 --- a/tests/ekore/anomalous_dimensions/unpolarized/space_like/test_as4.py +++ b/tests/ekore/anomalous_dimensions/unpolarized/space_like/test_as4.py @@ -17,8 +17,8 @@ NF = 5 n3lo_vars_dict = { - "gg": 17, - "gq": 24, + "gg": 19, + "gq": 21, "qg": 15, "qq": 6, } @@ -120,7 +120,7 @@ def test_momentum_conservation(): np.testing.assert_allclose( gnsp.gamma_nsp_nf1(N, sx_cache) + g_ps[:, 0] + g_gq[:, 1], 0, - atol=4e-11, + atol=7e-11, ) np.testing.assert_allclose( g_gg[:, 1] + g_qg[:, 0],