Basic Object Selection & Z candidates

After implying momentum & cut, one should also filter out those events with wrong lepton pair, which does not satisfy charge conservation.

Then pick the first one among four leptons, pair it with one of, if not the only, other leptons which is its anti-particle counterpart. After this process, one or two pair(s) of Z boson candidates can be constructed. However, we should choose the one pair which among the pair there is one Z boson as close to on-shell as possible.

After constructing and choosing the best fitting Z boson pairs, one can draw the distribution of constructed Z boson mass, separating by decay flavor or maximum/minimum in the pair. This leads to Figure 2 (by flavor) and Figure 3 (by energy).

Find & apply the best simple cut

By selecting the MC events which fits between and 131GeV, one can, for each event, construct a Z boson pair based on the method we have mentioned before. The constructed Z boson pair has two Z boson masses, one is , which is closer to (on-shell mass), comparing to the other one .

A cut confines and in a specific region on the plane. Four parameters are needed, implies that By sweeping through the parameter space, which is chosen to be , the optimal combination is .

By using , among the 71190 MC events which passed the cut, 63157 events are events, the significance value is 2.341.

By applying this fine-tuned cut to the MC events and real data, one can improve the diagram of the distribution of , to find Higgs signal. The result is shown in Figure 4.

Filtering events by BDT classifier

The ML library used is EvoTrees.jl. Here we are using a decision tree with depth of 4, trained 200 rounds, the loss algorithm is Logarithmic Loss.

For training, we split the MC events satisfied previous constraints in half. Half of the events are used for training, and the other half are used to find the optimal threshold. With this configuration, 70312 MC events passed, with 62604 Higgs events among them, and the significance is 2.341.

Using BDT with Z boson masses as input features yielded a result similar to the rectangular cut method. This similarity is expected, the kinematics of and are overlapping, which means BDT, which can be seen as offering a more fine-tuned cutting boundary, still won’t be able to tell them apart. The BDT could potentially offer greater improvements if additional kinematic variables is included.

The result with BDT filtering is shown in Figure 5.

Through the whole data set we do see some differences between BDT and rectangular cut. BDT does not filter out much when is too large, but this does not affect our result about Higgs boson.

All Julia and LaTeX source code can be found at this repo.

Simulation

If we can write some code to calculate Equation 1, then we can extract from it, by addressing its relation with . Calculating such a path-integral may seem to be impossible, however, doing MC simulation, we first simply generate a lot of “paths”, make sure their weight is proportional to , then perform measurements on those paths, get the mean of all measurements, then we will have the approximation of Equation 1.

First, make our x dimension-free might be a good idea, although it’s not necessary here. Then define a struct to hold all essential variables, write the function to calculate the change of action after imposing a perturbation at

using Pkg
Pkg.add("Plots")

using Base.Threads
using Random
using Plots

struct World
  xs::Vector{Float64}
  lt::Int
  m::Float64
  ω::Float64
  pt::Float64
  rb::Vector{Any}
end

function gen_world(lt, m, ω, pt)
  red_t = filter(isodd, 1:lt)
  black_t = filter(iseven, 1:lt)
  return World(zeros(lt), lt, m, ω, pt, [red_t, black_t])
end

function get_action_diff(w, t, new_x)
  lt = w.lt
  old_x = w.xs[t]

  act_diff = 0.5 * w.m * w.ω^2 * (new_x^2 - old_x^2)
  for t_nb in mod1.((t-1, t+1), lt)
    act_diff += 0.5 * w.m * (new_x - old_x) * (new_x + old_x - 2 * w.xs[t_nb])
  end

  return act_diff
end

Here we separate points in to groups so we can update each group in parallel. Then is how to update the path.

function update_xs!(w, t)
  new_x = w.xs[t] + (rand() - 0.5) * 2 * w.pt
  
  act_diff = get_action_diff(w, t, new_x)
  if act_diff >= 0
    if exp(- act_diff) < rand()
      return false
    end
  end

  w.xs[t] = new_x
  return true
end

function sweep_w!(w; save_accept=false)
  accepts = Atomic{Int}(0)
  @threads for t in w.rb[1]
    acc = update_xs!(w, t)
    if save_accept
      atomic_add!(accepts, Int(acc))
    end
  end
  @threads for t in w.rb[2]
    acc = update_xs!(w, t)
    if save_accept
      atomic_add!(accepts, Int(acc))
    end
  end
  return accepts[] / w.lt
end

Here exp(- act_diff) < rand() make sure that the weight is properly generated. However, when running the simulation, we need to tune how much perturbtion is made each time, to keep the accept rate to about 1/2.

And to measure, we iterate all path points and take the mean, for each

function measure_x2(w)
  x2_t = zeros(w.lt)
  for t_0 in 1:w.lt
    @threads for Δt in 0:(w.lt - 1)
      x2_t[Δt + 1] += w.xs[t_0] * w.xs[mod1(t_0 + Δt, w.lt)]
    end
  end
  x2_t = x2_t ./ w.lt
  return x2_t
end

Now the only thing left is to run the simulation and compare the result with our theoretical result, Equation 1.

w = gen_world(100, 1.0, 1.0 * 0.1, 2.0)

n_heat = 1000
println("HEATING...")
acc = 0
for i in 1:n_heat
  acc += sweep_w!(w; save_accept=true)
end
println("ACCEPTED RATE: $(acc / n_heat)")

n_measure = 1000

x2_t = zeros(w.lt)
println("MEASURING...")
for i in 1:n_measure
  for j in 1:1000
    sweep_w!(w)
  end
  x2_t .+= measure_x2(w)
end
x2_t ./= n_measure
push!(x2_t, x2_t[1])

Analyze the result, we have

Code

x2_normed = x2_t ./ sum(x2_t) .* 10.0

ts = (0:(w.lt)) ./ 10.0
function theo_fun(t)
  norm = 2.0 - exp(-10.0)
  return (exp(- 1.0 * t) + exp(- 1.0 * (10.0 - t))) / norm
end

p1 = plot(ts , x2_normed, label = "sim", color = :black, xlabel = "Time", ylabel="Correlation", framestyle = :box)
plot!(p1, ts, theo_fun, color = :red, label="theo", ls=:dash)

x2_samp = x2_normed[1:15]
t_samp  = ts[1:15]
p2 = plot(t_samp , log.(x2_samp), label = "sim", color = :black, xlabel = "Time", ylabel="ln(Correlation)", framestyle = :box)
plot!(p2, t_samp, (t) -> log(theo_fun(t)), color = :red, label="theo", ls=:dash)

plot(p1, p2, size=(800,400))

Note that only the slope in the second picture matters, which means it fits really well. So through this MC simulation, we can extract the difference between the first excited state and the groud state, which is in this case. More uses can be seen in Lattice-QCD, etc.

Basic components of axion-photon interaction

The effective axion-photon lagrangian can be written as: Here is the dual of . Focus on the interaction term, break out, we have: Then we get the interaction vertex in the form of (in momentum space): Here are the momentum of incoming and outcoming photons, amoung and , one flows into the vertex and and the other one flows out. Now recall the propagator of scalar particles and photons, we have:

• Axion propagator:
• Photon propagator:

Tree-level scattering amplitude

For the lowest order of photon-axion Compton-like scattering, only two Feynman diagrams contribute, one s-channel and one u-channel:

and we can write: along with: Then the total scattering amplitude is: Contract and simplify this impossible expression by FORM script and complete spin sum, we can finally get: This result is completely symmetric between and . And, at the limit of , , which is correct since the interaction vertex is proportional to photon momentum.

Numerical results

To understand this result more intuitively, we can draw some diagrams using julia:

using Pkg
Pkg.add("Plots")

using Plots

const m = 1e-4::Float64

function dot_p(x, y)
  prod = - x[1] * y[1] + sum([x[n] * y[n] for n in 2:4])
  return prod
end

function get_M2(s, u)
  m2 = + m^8 / 16 * (1/s + 1/u)^2 -
         m^4 / 8  * (u/s + s/u - 6) -
         m^2   *    (s + u) +
         5 / 16  *  (s + u)^2
  return m2 
end

function get_εp(ε, θ)
  εp = ε * m / (m + ε * (1 - cos(θ)))
  return εp
end

function get_M2s(ε, θs)
  M2s = Vector{Float64}(undef, length(θs))
  Threads.@threads for i in 1:length(θs)
    θ = θs[i]
    εp = get_εp(ε, θ)
    s = 2 * ε * m + m^2
    u = - 2 * εp * m + m^2

    M2s[i] = get_M2(s, u)
  end
  return M2s
end

θs = 0:1e-4:π
ε1 = 1e-5
M2s1 = get_M2s(ε1, θs)
ε2 = 1e-4
M2s2 = get_M2s(ε2, θs)
#ε3 = 1e-1
#M2s3 = get_M2s(ε3, θs)

display(plot(θs, M2s1, legend=false))
display(plot(θs, M2s2, legend=false))
#display(plot(θs, M2s3, lengend=false))

Something interesting is happening. When , there will always be a “peak” (infinite pole) in our scattering amplitude. This is actually because the axion can decay into 2 photons, and for an on-shell photon, it can travel for infinitely long time before interaction with another photon, which makes our scattering amplitude infinite. If we want to integral over to get total cross-section, we need to omit a small region around where the singularity appears.

Calculating the integral