•Text output

tRules = {Pair[_LorentzIndex, ___] -> Sequence[], _DecayConstant -> f, CouplingConstant[ChPTW3[2], 1] -> c2, CouplingConstant[ChPTW3[2], 2] -> c5, CouplingConstant[ChPTW3[4], i_] -> n[i], CouplingConstant[ChPT3[4], i_] -> L[i], MandelstamT -> t, MandelstamS -> s, MandelstamU -> u, ParticleMass[Pion] -> mPi, ParticleMass[Kaon] -> mK, ParticleMass[EtaMeson] -> mEta, ScaleMu -> Mu, Pair[Momentum[p2], Momentum[p2]] -> q^2, LeutwylerJBar[a__, ___Rule] :> Jbar[a]} ;

The leading-order contribution:

finallows1 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((I/2)*(c2*(-mK^2 + q^2)*(-mK^2 + 4*mPi^2 + q^2 - 3*s) + 2*c5*(mK^2 - mPi^2)*(-mK^2 + q^2 + s)))/
(f^2*(-mK^2 + q^2))

The logs from the wave-function renormalized leading-order contribution:

lows2 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

(((I/3456)*(-4*mK^2 + mPi^2)*(4*c5*(-7*mK^4 - 4*mK^2*mPi^2 + 2*mPi^4 + (11*mK^2 - 2*mPi^2)*q^2 +
       9*mK^2*s) + c2*(mK^4 + 9*q^4 + q^2*(-10*mK^2 + 34*mPi^2 - 27*s) + 3*mK^2*s +
       mPi^2*(-34*mK^2 + 6*s)))*Log[mEta^2/Mu^2])/(Pi^2*(-mK^2 + q^2)) +
  ((I/192)*mK^2*(4*c5*(-mK^2 + mPi^2)*(-3*mK^2 + 3*q^2 + 5*s) +
     c2*(-7*q^4 + q^2*(12*mK^2 - 28*mPi^2 + 21*s) + mK^2*(28*mPi^2 - 5*(mK^2 + 3*s))))*
    Log[mK^2/Mu^2])/(Pi^2*(-mK^2 + q^2)) +
  ((I/384)*mPi^2*(4*c5*(2*mPi^4 + mK^2*(9*mK^2 - 9*q^2 - 11*s) + 2*mPi^2*(-7*mK^2 + 6*q^2 + 7*s)) +
     c2*(-19*q^4 + mPi^2*(70*mK^2 - 18*s) + q^2*(38*mK^2 - 70*mPi^2 + 57*s) - 19*(mK^4 + 3*mK^2*s)))*
    Log[mPi^2/Mu^2])/(Pi^2*(-mK^2 + q^2)))/f^4

The Overscript[J, _] parts of the loop contribution in proportion to c _ 2:

finaljbars2KLMs /. _RenormalizationState -> Sequence[] //. tRules // InputForm

((I/864)*c2*(24*mPi^2*(-13*mK^2 + 4*mPi^2 - 3*q^2 + 9*s)*Jbar[s, mEta^2] -
   108*(3*mK^2 + q^2 - 3*s)*s*Jbar[s, mK^2] - 216*(-mPi^2 + 2*s)*(mK^2 - 4*mPi^2 - q^2 + 3*s)*
    Jbar[s, mPi^2] + (302*mK^4 - 97*mPi^4 - 3*q^2*(-91*mK^2 + 19*mPi^2 + 24*t) + 18*t*(7*t + 5*u) -
     60*mK^2*(8*t + 7*u) + mPi^2*(443*mK^2 - 24*t + 60*u))*Jbar[t, mK^2, mEta^2] +
   9*(-42*mK^4 - 13*mPi^4 + q^2*(-19*mK^2 + 35*mPi^2 - 16*t) + mPi^2*(103*mK^2 - 64*t - 4*u) -
     4*mK^2*(6*t + u) + 2*t*(23*t + u))*Jbar[t, mPi^2, mK^2] +
   (302*mK^4 - 97*mPi^4 + mPi^2*(443*mK^2 + 60*t - 24*u) + 18*u*(5*t + 7*u) - 60*mK^2*(7*t + 8*u) -
     3*q^2*(-91*mK^2 + 19*mPi^2 + 24*u))*Jbar[u, mK^2, mEta^2] +
   9*(-42*mK^4 - 13*mPi^4 + mPi^2*(103*mK^2 - 4*t - 64*u) + q^2*(-19*mK^2 + 35*mPi^2 - 16*u) -
     4*mK^2*(t + 6*u) + 2*u*(t + 23*u))*Jbar[u, mPi^2, mK^2] +
   12*(-35*mPi^4 + mK^2*(-26*mK^2 + 13*q^2 - 5*u) + mPi^2*(31*mK^2 + 17*q^2 + 5*u))*
    K[t, mK^2, mEta^2] + 36*(17*mPi^4 + mPi^2*(23*mK^2 - 11*q^2 + u) - mK^2*(10*mK^2 + 19*q^2 + u))*
    K[t, mPi^2, mK^2] + 12*(-35*mPi^4 + mK^2*(-26*mK^2 + 13*q^2 - 5*t) +
     mPi^2*(31*mK^2 + 17*q^2 + 5*t))*K[u, mK^2, mEta^2] +
   36*(17*mPi^4 + mPi^2*(23*mK^2 - 11*q^2 + t) - mK^2*(10*mK^2 + 19*q^2 + t))*K[u, mPi^2, mK^2] +
   540*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*Mr[t, mK^2, mEta^2] + 108*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*
    Mr[t, mPi^2, mK^2] + 540*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*Mr[u, mK^2, mEta^2] +
   108*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*Mr[u, mPi^2, mK^2]))/f^4

The polynomial parts of the loop contribution in proportion to c _ 2:

finallooppolys2 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((I/1152)*c2*(-103*mK^4 - 84*q^4 + 5*mK^2*(-73*mPi^2 + 57*s) + q^2*(-187*mK^2 - 311*mPi^2 + 138*s) +
   3*(-90*mPi^4 + 37*mPi^2*s + 58*t*u + 28*(t^2 + u^2))))/(f^4*Pi^2)

The log parts of the loop contribution in proportion to c _ 2:

finallooplogs2 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((I/24)*c2*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*(5*k[mK^2, mEta^2] + k[mPi^2, mK^2]))/f^4 +
((I/6912)*c2*(-((760*mK^6 - 40*mPi^6 + 6*mK^4*(241*mPi^2 + 156*q^2 - 252*s) +
       18*mPi^4*(-7*q^2 + 9*s) + 9*mPi^2*(4*q^2*(-q^2 + s) + 10*t*u + 7*(t^2 + u^2)) -
       6*mK^2*(37*mPi^4 - 9*mPi^2*(3*q^2 + s) + 6*(4*q^2*(-q^2 + s) + 10*t*u + 7*(t^2 + u^2))))*
      Log[mEta^2/Mu^2]) - 18*(13*mK^6 + 3*mPi^2*s*(-q^2 + 3*s) + mK^4*(-92*mPi^2 - 20*q^2 + 107*s) -
      mK^2*(-100*mPi^4 - 7*q^4 + 113*mPi^2*s + q^2*(-48*mPi^2 + 13*s) + 4*t*u + 10*(t^2 + u^2)))*
     Log[mK^2/Mu^2] + 9*(-160*mPi^6 - 24*mK^2*s*(mK^2 - q^2 + 3*s) +
      mPi^4*(-362*mK^2 - 234*q^2 + 38*s) + mPi^2*(-30*mK^4 - 64*q^4 + 370*mK^2*s +
        2*q^2*(-71*mK^2 + 56*s) + 142*t*u + 49*(t^2 + u^2)))*Log[mPi^2/Mu^2]))/
  (f^4*(-mK^2 + mPi^2)*Pi^2)

The Overscript[J, _] parts of the loop contribution in proportion to c _ 5:

finaljbars5KLMs /. _RenormalizationState -> Sequence[] //. tRules // InputForm

((-I/144)*c5*(mK^2 - mPi^2)*(-8*mPi^2*(-9*mK^2 + q^2 + 9*s)*Jbar[s, mEta^2] -
   108*s*(-mK^2 + q^2 + s)*Jbar[s, mK^2] - 72*(-mK^2 + q^2 + s)*(-mPi^2 + 2*s)*Jbar[s, mPi^2] -
   (-46*mK^4 + 5*mPi^4 + 18*t*(t - u) - 3*mPi^2*(-7*q^2 + 8*t + 4*u) +
     mK^2*(-31*mPi^2 - 45*q^2 + 24*t + 84*u))*Jbar[t, mK^2, mEta^2] -
   9*(-3*mPi^4 + q^2*(3*mK^2 + 13*mPi^2 - 8*t) - 2*mK^2*(3*mK^2 + 8*t - 2*u) + 2*t*(9*t - u) +
     mPi^2*(25*mK^2 - 24*t + 4*u))*Jbar[t, mPi^2, mK^2] +
   (46*mK^4 - 5*mPi^4 + 18*(t - u)*u - 3*mK^2*(-15*q^2 + 28*t + 8*u) +
     mPi^2*(31*mK^2 - 21*q^2 + 12*t + 24*u))*Jbar[u, mK^2, mEta^2] +
   9*(6*mK^4 + 3*mPi^4 - 4*mK^2*(t - 4*u) + 2*(t - 9*u)*u + q^2*(-3*mK^2 - 13*mPi^2 + 8*u) +
     mPi^2*(-25*mK^2 - 4*t + 24*u))*Jbar[u, mPi^2, mK^2] +
   12*(2*mK^4 - mK^2*(mPi^2 - 5*q^2 + u) + mPi^2*(-7*mPi^2 + q^2 + u))*K[t, mK^2, mEta^2] +
   36*(2*mK^4 - mK^2*(mPi^2 - q^2 + u) + mPi^2*(-3*mPi^2 + q^2 + u))*K[t, mPi^2, mK^2] +
   12*(2*mK^4 - mK^2*(mPi^2 - 5*q^2 + t) + mPi^2*(-7*mPi^2 + q^2 + t))*K[u, mK^2, mEta^2] +
   36*(2*mK^4 - mK^2*(mPi^2 - q^2 + t) + mPi^2*(-3*mPi^2 + q^2 + t))*K[u, mPi^2, mK^2] +
   108*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*Mr[t, mK^2, mEta^2] + 108*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*
    Mr[t, mPi^2, mK^2] + 108*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*Mr[u, mK^2, mEta^2] +
   108*(-mK^2 + mPi^2)*(-mPi^2 + q^2)*Mr[u, mPi^2, mK^2]))/(f^4*(-mK^2 + q^2))

The polynomial parts of the loop contribution in proportion to c _ 5:

finallooppolys5 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((I/576)*c5*(mK^2 - mPi^2)*(66*q^4 + q^2*(147*mK^2 + 283*mPi^2 - 192*s) -
   3*(-27*mK^4 - 90*mPi^4 + 37*mK^2*s + mPi^2*(-99*mK^2 + 89*s) + 46*t*u + 22*(t^2 + u^2))))/
(f^4*Pi^2*(-mK^2 + q^2))

The log parts of the loop contribution in proportion to c _ 5:

finallooplogs5 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((I/4)*c5*(-mK^2 + mPi^2)^2*(-mPi^2 + q^2)*(k[mK^2, mEta^2] + k[mPi^2, mK^2]))/(f^4*(-mK^2 + q^2)) +
((I/3456)*c5*((-112*mK^6 - 8*mPi^6 + 64*mK^4*(-4*q^2 + 9*s) + 4*mPi^4*(3*mK^2 - 4*q^2 + 36*s) +
      mPi^2*(-4*mK^2*(54*mK^2 - 41*q^2 + 99*s) + 27*(t - u)^2) - 108*mK^2*(t - u)^2)*
     Log[mEta^2/Mu^2] + 18*(33*mK^6 + mK^4*(66*mPi^2 + 36*q^2 - 49*s) + 9*mPi^2*s*(q^2 + s) -
      mK^2*(-48*mPi^4 + mPi^2*(-42*q^2 + 47*s) + 3*(-5*q^4 + 11*q^2*s + 8*t*u + 6*(t^2 + u^2))))*
     Log[mK^2/Mu^2] + 9*(-152*mPi^6 - 24*mK^2*s*(-mK^2 + q^2 + s) +
      4*mPi^4*(-25*mK^2 - 36*q^2 + 28*s) + mPi^2*(-60*mK^4 - 36*q^4 + 56*mK^2*s +
        12*q^2*(-3*mK^2 + 7*s) + 42*t*u + 51*(t^2 + u^2)))*Log[mPi^2/Mu^2]))/(f^4*Pi^2*(-mK^2 + q^2))

Weak counterterms contributing also to K->2π:

oldcts /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((-I/3)*c2*(3*mPi^2*(-(q^2*(n[8] + 2*n[9])) + s*(4*n[5] + 8*n[7] + 3*n[8] + 2*n[9])) +
   2*mK^4*(3*n[5] + 3*n[8] - 8*(n[10] + n[11])) -
   (2*(mK^2 - mPi^2)*(mK^2 - q^2 + 3*s)*(mPi^2*n[11] + 2*mK^2*(n[10] + n[11])))/(-mK^2 + q^2) -
   4*mPi^4*(6*n[5] + 12*n[7] + 3*n[8] - 6*n[10] - 14*n[11] - 6*n[12]) +
   mK^2*(-6*q^2*(n[5] + n[8]) + 6*s*(n[5] - 4*n[7] + 3*n[8] + 2*n[9]) +
     mPi^2*(48*n[7] - 21*n[8] - 18*n[9] - 8*(n[10] + 5*n[11] + 3*n[12])))))/f^4

Weak conterterms not contributing to K->2π:

cts2 /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((I/6)*c2*(3*(-mK^4 - 6*mPi^4 - q^4 + 2*mPi^2*s + mK^2*(-2*mPi^2 + s) +
     q^2*(-4*mK^2 - 2*mPi^2 + s) + t^2 + 4*t*u + u^2)*n[19] -
   3*(-mK^4 - 6*mPi^4 - 3*q^4 + 2*mPi^2*s + mK^2*(-2*mPi^2 + s) + q^2*(-2*mK^2 - 10*mPi^2 + 7*s) +
     t^2 + 4*t*u + u^2)*n[20] - 3*mK^4*(2*n[21] + n[22] + 2*n[23]) -
   4*mPi^2*((-4*q^2 + 6*s)*n[21] + 3*s*(n[22] + 2*n[23])) +
   mK^2*(2*(12*mPi^2 - 5*q^2 + 3*s)*n[21] + 3*(4*mPi^2 + q^2 + s)*(n[22] + 2*n[23]))))/f^4

Strong counterterms:

strongcts /. _RenormalizationState -> Sequence[] /. tRules // InputForm

((-4*I)*c5*(mK^2 - mPi^2)*(8*(mK^2 + q^2 - s)*(-2*mPi^2 + s)*L[1] +
   4*(-2*mPi^4 + 2*mPi^2*s - s^2 + mK^2*(-2*mPi^2 + s) + q^2*(-2*mK^2 - 2*mPi^2 + s) + 2*t*u)*L[2] +
   10*mPi^4*L[3] + 6*mPi^2*q^2*L[3] + 3*q^4*L[3] - 6*mPi^2*s*L[3] - 3*q^2*s*L[3] - 6*mPi^2*t*L[3] -
   3*q^2*t*L[3] + 3*s*t*L[3] - 6*mPi^2*u*L[3] - 3*q^2*u*L[3] + 3*s*u*L[3] + 2*t*u*L[3] +
   6*mPi^2*q^2*L[4] - 10*mPi^2*s*L[4] - 4*mPi^2*s*L[5] + 4*mPi^2*q^2*L[6] + 4*mPi^2*s*L[6] +
   mK^2*(q^2*L[3] - 2*(-13*mPi^2 + 2*q^2 + 6*s)*L[4] + 4*mPi^2*(2*L[5] - 9*L[6] - 5*L[8]) -
     2*(q^2 + s)*(L[5] - 4*L[6] - 2*L[8])) + 2*mK^4*(2*L[4] + L[5] - 4*L[6] - 2*L[8]) +
   4*mPi^2*q^2*L[8] + 4*mPi^2*s*L[8]))/(f^4*(-mK^2 + q^2))

Converted by Mathematica  (July 10, 2003)