• 1. Domain wall in phi-fourth model
• 2. Normal Modes
• 3. Fourier Transform
• 4. Numeric Results
  • 4.1 Summation method

1. Domain wall in phi-fourth model

Recall that we are working in $D = d+1$ dimensional space-time, the space-dimension is $d$. For now let’s consider $d=2$. In 2-dimensional space, a kink can extend to form a domain wall, for more info about domain walls see my other note. The world line of such a domain wall would be world sheet. Now let’s try to calculate the quantum corrections to the tension of such a domain wall.

The energy is given by the space integral of the Hamiltonian density,

where

Note that we have written $\phi$ as $\tilde{\phi}$ so that the coupling becomes an overall pre-factor. Keep in mind that, in this formalism, the energy is no longer simply $H=\int \, V$ but $H = \int \, V / \lambda$.

Let the spatial coordinates be $x$ and $y$. Consider the potential (expanded in the negative vacuum)

Now consider a flat domain wall in $x=0$ plane. The classical kink solution in the $x$-direction is

where again, $\widetilde{f} = \sqrt{ \lambda }f$ by definition.

The energy now reads

where $\rho_ {0}$ is now interpreted as the tension of the domain wall. The calculation is exactly the same as for the kink energy, but to refresh the memory I decided to do it again.

Introduce a new variable $t := \frac{mx}{2}$, we have

The potential contribution to the energy is

where we have used

Similarly, the contribution from the space-derivative term reads

Putting Eq. (1) and Eq. (2) together, we have

The dimensional analysis gives us

hence in $2+1$ dimension the coupling has dimension of mass.

2. Normal Modes

Since we assumed the domain wall to be lying flat in the $y$-plane, the normal modes in 2-d space can be factorized into $x$ and $y$ components,

The normal modes are the solution of the equation of motion in the kink background, or Poschl-Teller potential. These modes include a continuum

with eigenvalue $\omega_ {k} = \sqrt{ k^{2}+m^{2} }$, a zero mode

with eigenvalue $0$, and a shape mode

with eigenvalue less then the rest mass of excited particle.

Momentum in the $y$-direction also contributes to the total energy, putting them together with the zero modes, shape modes and continuum in the $x$ direction we have

Note that

• there is a zero mode corresponding to $k_ {B},k_ {y}=0$,
• the mass gap disappears, due to the mass-gap-less of $y$-momentum.

The formalism we developed in generic dimension $d$ surely also applies to $d=2$. Let $\vec{p}=(p_ {x},p_ {y})$ and $\vec{k}=(k_ {x},k_ {y})$. The Fourier transform is

Again we see the factorization in $x$ and $y$, the $\delta$-function in $y$ direction is due to the plane wave expansion.

Note that the infinite volume of a flat $\mathbb{R}$ can be written as Dirac-$\delta$ function $\delta(0)$. To see it, recall the Fourier transform of a function is written as

which means if we set $f(\vec{x})=1$ then

If we further set $k=0$ then the integral becomes

In the case of 1-dimension, say coordinated by $y$, the total length would be $2\pi \delta(0)$.

This identity comes in handy when we take the factorized expression Eq. (3) into the one-loop correction

In the above equation we have set the dimensionality $d$ to $2$. $\omega_ {k}$ is the short-handed form for $\omega_ {k_ {x}k_ {y}}$, the same for $\omega_ {p}$. Note that starting from the third line, we have $\omega_ {k}=\omega_ {k_ {x} p_ {y}}$ due to the Dirac-$\delta$ function. The integral regarding $y$-coordinate gives as a term proportional to $(2\pi)\delta(0)$, which is the total length of the $y$-direction. $L_ {\text{DM}}$ is the length of the domain wall, $L_ {\text{DM}}=\int dy$. It is understood that in the final result $p_ {y}=-k_ {y}$. It agrees with our naive expectation that the correction is proportional to the total length of the domain wall.

Eq. (4) can also be written as

Here again $\omega_ {k}$ is understood to be $\omega_ {k_ {x} k_ {y}}$, and we have defined the one-loop correction $\rho_ {1}$ to the tension. Note that one-loop correction comes not from the interaction, as in QFT models in the vacuum sector, but rather comes from the non-trivial soliton background.

3. Fourier Transform

We still need to evaluate the one-loop correction

To do this, first we need to Fourier-Transform various normal modes.

To Fourier transform it we use Mathematica. In Mathematica, the convention used for the Fourier transform is represented by the function FourierTransform[expr, t, ω], where expr is the expression to be transformed, t is the time variable, and ω is the frequency variable. This gives the symbolic Fourier transform of the expression. For multidimensional Fourier transforms, you can use FourierTransform[expr, {t1, t2, …}, {ω1, ω2, …}], but here we won’t need it.

The basis function used by Mathematica’s FourierTransform is dependent on the FourierParameters setting. The FourierParameters option is specified as {a, b}, where a and b are parameters that influence the Fourier transform’s definition. Specifically, they appear in the exponential factor and the normalization constant of the Fourier transform equations. The default setting for FourierParameters in Mathematica is {0, 1}, which corresponds to using the basis function $e^{i t \omega}$ for the Fourier transform,

where $\mathcal{F}\left\lbrace f \right\rbrace$ is the Fourier transform of function $f(t)$. In general, under FourierParameters->{a,b} the Fourier Transform is set to be

In order to change it to our desired basis, we need to set $a=1,b=-1$, which is the so-called physics convention. As a test let’s try to transform a plane wave $\exp(-ipx)$, with our convention mathematica should return $2\pi \delta(p+k)$. The code reads

FourierTransform[Exp[-I p x], x, k, FourierParameters -> {1, -1}]

which indeed returns 2 Pi DiracDelta[k + p].

The shape mode

The shape mode as a function of $x$ reads

whose Fourier transform can be calculated with mathematica code

fkgS[x_] := Sqrt[3 m]/2 Tanh[(m x)/2] Sech[ (m x)/2];
FourierTransform[fkgS[x], x, p, FourierParameters -> {1, -1}]

The result reads

The zero mode

From the following Mathematica code

fkgB[x_] := -Sqrt[((3 m)/8)] Sech[(m x)/2]^2;
FourierTransform[fkgB[x], x, k, FourierParameters -> {1, -1}]

we have

The continuum

The Fourier transform is given by the following Mathematica code,

fkgk[x_] :=E^(-I k x)/(\[Omega]k Sqrt[m^2+4k^2])(2k^2-m^2+3/2 m^2 Sech[(m x)/2]^2 - 3I m k Tanh[(m x)/2]);
FourierTransform[fkgk[x], x, p, FourierParameters -> {1, -1}]

which gives us

However, if we perform the Fourier transform term-by-term we get

In[1]:= FourierTransform[E^(-I k x)/(\[Omega]k Sqrt[m^2 + 4 k^2]) (2 k^2 - m^2), x, p, 
 FourierParameters -> {1, -1}]

Out[1]= (2 (2 k^2 - m^2) \[Pi] DiracDelta[k + p])/(Sqrt[4 k^2 + m^2] \[Omega]k)

In[2]:= FourierTransform[E^(-I k x)/(\[Omega]k Sqrt[m^2 + 4 k^2]) (3/2 m^2 Sech[(m x)/2]^2), x, p, 
 FourierParameters -> {1, -1}]

Out[2]= (6 (k + p) \[Pi] Csch[((k + p) \[Pi])/m])/(Sqrt[4 k^2 + m^2] \[Omega]k)

In[3]:= FourierTransform[E^(-I k x)/(\[Omega]k Sqrt[m^2 + 4 k^2]) (-3 I m k Tanh[(m x)/2]), x, p, 
 FourierParameters -> {1, -1}]

Out[3]= -((6 k \[Pi] Csch[((k + p) \[Pi])/m])/(Sqrt[4 k^2 + m^2] \[Omega]k))

Putting them together we get

I have no idea why this delta function disappeared. Any help here?

Let’s proceed to calculate $\rho_ {1}$. Since $k_ {x}$ is separated into three parts, i.e. zero mode, shape mode and continuum, we can separate $\rho_ {1}$ into three corresponding parts, writing

where

The subscript $C$ in $\rho_ {1C}$ stands for continuum.

We have separated the integral over $d^{2}p$ into its two components for a reason, so we can perform the integral over the flat direction $p_ {y}$ analytically first. For the sake of convenience let’s define a general integral of form

With the help of mathematica again we get

This form shows that if $a=b$ then $\mathcal{I}_ {ab}=0$, as it should be by definition. If we allow the parameters of $\ln$ function to be dimensionful, another form is more useful to us,

This form made obvious that $\mathcal{I}(a,b)$ behaviors nice at $a=0$.

To calculate Eq. (6), recall that (since $k_ {y}=-p_ {y}$)

We have

The last line is obtained by Mathematica code

tldgB[p_] := -((Sqrt[6] \[Pi] p) /m^(3/2)) Csch[(p \[Pi])/m];
Integrate[-1/(8 \[Pi]) 1/(2 Pi) tldgB[px]^2 (m^2 + px^2), {px, -\[Infinity], \[Infinity]}, 
 Assumptions -> {m > 0, m \[Element] Reals}]

Next let’s move on to Eq. (7). We have

where

We’ll have to turn to numerical calculation now. For the sake of numerical calculation, we better change $p_ {x}$ to something without dimension. Set $t:= p_ {x} / m$, we have

All of this gives us

It is a little harder to do Eq. (8).

where

This leaves

Now we simply need to substitute

where $\omega_ {k_ {x}} = \sqrt{ m^{2}+k_ {x}^{2} }$. Note that since $\mathcal{I}(m^{2}+k_ {x}^{2},m^{2}+p_ {x}^{2})$ equals to zero when $p=-k$, hence we can discard the $\delta$ term and focus on the $\text{csch}$ term.

Again we have to turn to numerical methods, and again we need to cook up some dimension-less variables from $k_ {x}$ and $p_ {x}$. Define $\kappa:= k_ {x} / m$ and $\rho := p_ {x} / m$, we have

The figure of the integral is shown in the below.

The numerical result shows that the total contribution is

which is slightly different from that in the draft where $\rho_ {1C}=−0.03156 m^{2}$. We will explain how we get the numerical result and how reliable they are in the following section.

4. Numeric Results

Result Using Mathematica function NIntegral

We can directly perform the double integral over $dk_ {x}dp_ {x}$, based on Eq. (5.18) in the paper. Using the Mathematica code in the following (it is meant to be copied and opened in Mathematica notebook)

Module[{integrandTem}, 
 integrandTem[\[Kappa]_, \[Rho]_] := - (9/(2*4 Pi*(1 + \[Kappa]^2) (1 + 4 \[Kappa]^2))) \[Rho]^2 (Csch[Pi (\[Kappa] + \[Rho])])^2 (-\[Kappa]^2 + \[Rho]^2 - (1 + \[Kappa]^2) Log[(1 + \[Rho]^2)/(1 + \[Kappa]^2)]); 
 NIntegrate[integrandTem[\[Kappa], \[Rho]], {\[Kappa], -\[Infinity], \[Infinity]}, {\[Rho], -\[Infinity], \[Infinity]}]
 ]

where $\kappa := k_ {x} / m$ and $\rho := p_ {x} / m$, they are the reduced momenta.

We get -0.0290278 without any error or warning message. However since the slow-converging nature and the fact that the 2D integral domain is infinity, this result is not very reliable, especially it differs from results that we got from more reliable method, which we will elaborate in the following.

When the parameter WorkingPrecision and MaxRecursion is set too high, $50$ for example, the integral result will be unstable and oscillates wildly. It can be seen from running the following code, we will skip the final result rather just mention that it doesn’t work.

Module[{data}, 
 rho1kx[\[Kappa]_] := 
  NIntegrate[
   integrand[\[Kappa], \[Rho]], {\[Rho], -\[Infinity], \[Infinity]}, 
   WorkingPrecision -> 50, MaxRecursion -> 50, PrecisionGoal -> 50, 
   AccuracyGoal -> 50];
 Plot[rho1kx[\[Kappa]], {\[Kappa], -10, 10}]]

Similarly, PrecisionGoal->50 does not help, for the result is not even monotonically decreasing at large $k_ {x}$, we list the code and the result:

Module[{data}, 
 rho1kx[\[Kappa]_] := 
  NIntegrate[
   integrand[\[Kappa], \[Rho]], {\[Rho], -\[Infinity], \[Infinity]}, 
   WorkingPrecision -> 50, MaxRecursion -> 50, PrecisionGoal -> 50, 
   AccuracyGoal -> 50];
 data = Table[{\[Kappa], rho1kx[\[Kappa]]}, {\[Kappa], 0, 100, 10}];
 TableForm[data, 
  TableHeadings -> {None, {"\[Kappa]", "rho1kx[\[Kappa]]"}}]]

It shows wild oscillation, hence is not trust-worthy.

With reasonable options

NIntegrate[
 rho1kx[\[Kappa]]/(2 Pi), {\[Kappa], -\[Infinity], \[Infinity]},
 WorkingPrecision -> 30, PrecisionGoal -> 6, AccuracyGoal -> 6
 ]

we get the following result:

NIntegrate failed to converge to prescribed accuracy after 9 recursive bisections in [Kappa] near {[Kappa]} = {169.954045306876363791355871581}. NIntegrate obtained -0.0313611336264321023970618041371 and 2.68446200766726199070353491885 * 10^-6 for the integral and error estimates”.

Which translates to $\boxed {-0.031361 \pm 0.0000027}$. However, the origin of this error estimation is unclear to me, and multiple warnings about converging too slowly make it even less convincing. This motivates us to try another more direct but more controllable method to perform the integral.

Cutoff on $\rho$-integral

Let’s take a closer look at the integral Eq. (9). The integrand contains a factor roughly $\text{csch}^{2}(\kappa+\rho )$, proportional to $e^{-2 (\kappa+\rho) }$, a exponential suppression. When $\kappa$ is fixed, the only integral domain that contributes to the integral is $\rho \in (\kappa-\Lambda,\kappa+\Lambda)$ for some cutoff $\Lambda$. The below numerical results will show that it is sufficient for $\Lambda=4$. We compare the integrals with and without a cutoff, and calculate the numerical difference. The Mathematica code is as follow.

(*cut_:4 means the defalut value for cut is 4, which is  used unless \
an explicit value is provided for cut in the function call. rho1kxCut \
can be called as, for example, rho1kxCut[0] or rho1kxCut[0,6] *)

integrand[\[Kappa]_, \[Rho]_] := -((
   9 \[Rho]^2 Csch[\[Pi] (\[Kappa] + \[Rho])]^2 (-\[Kappa]^2 + \
\[Rho]^2 + (1 + \[Kappa]^2) Log[(1 + \[Kappa]^2)/(1 + \[Rho]^2)]))/(
   4 (1 + 5 \[Kappa]^2 + 4 \[Kappa]^4)));
rho1kxCut[\[Kappa]_, cut_ : 4] := 
  NIntegrate[
   integrand[\[Kappa], \[Rho]], {\[Rho], -\[Kappa] - cut, -\[Kappa] + 
     cut}];

Module[{data},
 rho1kxOld[\[Kappa]_] := 
  NIntegrate[
   integrand[\[Kappa], \[Rho]], {\[Rho], -\[Infinity], \[Infinity]}];
 data = Table[{\[Kappa], 
    rho1kxCut[\[Kappa]], (rho1kxCut[\[Kappa]] - rho1kxOld[\[Kappa]])/
     rho1kxOld[\[Kappa]]}, {\[Kappa], 0, 70, 5}];
 Labeled[
  TableForm[data, 
   TableHeadings -> {None, {"\[Kappa]", "rho1kxCut[\[Kappa]]", 
      "Relative Error"}}], 
  "\[Rho]\[Element](-\[Kappa]-4,-\[Kappa]+4)", Top]
 ]

The result is shown in the following, where relative error is defined as $(\text{cut}-\text{uncut})/\text{cut}$.

$\rho \in(\kappa-4,\kappa+4)$

$\rho \in(-\kappa-5,-\kappa+5)$:

For $\rho \in(\kappa-4,\kappa+4)$, the relative error is negligible. Hence we will used the cutoff version.

4.1. Summation method

At lower values of $\kappa$ we can afford finer step size, the basic Mathematica code we are gonna use is (ignore it or copy to a note book to read)

(*Set up the discretization parameters*)
\[CapitalLambda] = 50;
\[Kappa]Min = -\[CapitalLambda];  (*LargeValue should be a large \
number representing the approximation to -Infinity*)
\[Kappa]Max = \[CapitalLambda];   (*Similarly for +Infinity*)
stepSize = 
  0.1;  (*DesiredStep is the step size for the discretization,choose \
based on desired precision*)

(*Sum up the values of rho1kx over the range using the specified step \
size*)
(*The first argument defined the range of Subscript[\[Rho], \
1Subscript[k, x]], the second argument defines the step size.*)

totalSum[\[CapitalLambda]_, stepSize_] := 
 Module[{\[Kappa]Min = -\[CapitalLambda], \[Kappa]Max = \
\[CapitalLambda]},
  Sum[rho1kxCut[\[Kappa]]*
    stepSize, {\[Kappa], \[Kappa]Min, \[Kappa]Max, stepSize}]/(2 Pi)]
 

To see if summation method is stable at step size $0.01$ for various $\Lambda$, execute

Module[{data},
 data = Table[
   totalSum[\[CapitalLambda], 
    stepSize], {\[CapitalLambda], {1, 20, 1}}, {stepSize, {0.01}}];
 TableForm[data, 
  TableHeadings -> {Table[
     "\[CapitalLambda]=" <> 
      ToString[\[CapitalLambda]tem], {\[CapitalLambda]tem, 20}], 
    Table["stepSize=" <> ToString[a], {a, {0.01}}]}]
 ]

and we get

$\text{step size=0.01}$, $\kappa \in(-\Lambda,+\Lambda)$:

Looks stable enough.

I decided to increase the upper and lower limit $\Lambda$ until the first four or five digit (after the decimal point) stabilizes, with step size 0.01, and include the $2\pi$ factor:

(*cut_:4 means the defalut value for cut is 4, which is  used unless \
an explicit value is provided for cut in the function call. rho1kxCut \
can be called as, for example, rho1kxCut[0] or rho1kxCut[0,6] *)

integrand[\[Kappa]_, \[Rho]_] := -((
   9 \[Rho]^2 Csch[\[Pi] (\[Kappa] + \[Rho])]^2 (-\[Kappa]^2 + \
\[Rho]^2 + (1 + \[Kappa]^2) Log[(1 + \[Kappa]^2)/(1 + \[Rho]^2)]))/(
   4 (1 + 5 \[Kappa]^2 + 4 \[Kappa]^4)));
rho1kxCut[\[Kappa]_, cut_ : 4] := 
  NIntegrate[
   integrand[\[Kappa], \[Rho]], {\[Rho], -\[Kappa] - cut, -\[Kappa] +  cut}];

(*Set up the discretization parameters*)
\[CapitalLambda] = 50;
\[Kappa]Min = -\[CapitalLambda];  (*LargeValue should be a large \
number representing the approximation to -Infinity*)
\[Kappa]Max = \[CapitalLambda];   (*Similarly for +Infinity*)
stepSize = 
  0.1;  (*DesiredStep is the step size for the discretization,choose \
based on desired precision*)

(*Sum up the values of rho1kx over the range using the specified step \
size*)
(*The first argument defined the range of Subscript[\[Rho], \
1Subscript[k, x]], the second argument defines the step size.*)

totalSum[\[CapitalLambda]_, stepSize_] := 
 Module[{\[Kappa]Min = -\[CapitalLambda], \[Kappa]Max = \
\[CapitalLambda]},
  Sum[rho1kxCut[\[Kappa]]*
    stepSize, {\[Kappa], \[Kappa]Min, \[Kappa]Max, stepSize}]/(2 Pi)]
 
Module[{data},
 data = Table[
   totalSum[\[CapitalLambda], 
    stepSize], {\[CapitalLambda], {50, 170, 5}}, {stepSize, {0.01}}];
 TableForm[data, 
  TableHeadings -> {Table[
     "\[CapitalLambda]=" <> 
      ToString[\[CapitalLambda]tem], {\[CapitalLambda]tem, 20}], 
    Table["stepSize=" <> ToString[a], {a, {0.01}}]}]
 ]

We get

With step size 0.01, the first four digits after decimal point can no longer be improved by enlarging $\Lambda$.

Next, we divide the integral domain into an inner region where we use fine summations (smaller step size) and an outer region where we use coarser summation (large step size), separated by an limit $\Lambda=1600$. We do two things simultaneously, 1) increase the inner region step size from $0.005$ to $0.01$ and 2) increase the outer region step size from $0.05$ to $0.1$ until the first four or five digits after the decimal point stabilizes.

$\Lambda=1600$, Upper limit of $\kappa$ is set to be 10 000.

In the following table, large step size means 0.01 for inner region and 0.1 for outer region; small step size means 0.005 for inner region and 0.05 for outer region. Hope I had a stronger computer…