Прямое измерение массы нейтрино. Кинематика β-спектра

Введение в физику нейтрино

Дмитрий В. Наумов

ОИЯИ

У нейтрино есть масса

У нейтрино есть ненулевая масса

• Осцилляции нейтрино надежно наблюдаются. Следовательно \[ \Delta m^2_{ij}\ne 0. \]
• Масса нейтрино отлична от нуля, а также \(m_i\ne m_j\).
• Как измерить массы, а не разности квадратов масс?

Метод измерения массы нейтрино в \(\beta\)-распадах

• Идея измерения формы \(\beta\)-спектра для определения массы нейтрино предложена Перреном (1933) и Ферми (1934)
• Первые эксперименты с использованием этого метода выполнены Курраном, Ангусом и Кокрофтом (1948) и Ханной и Понтекорво (1949)

Суть метода

Для одного массового состояния нейтрино:

\[ \frac{d\Gamma}{dE} \propto \underbrace{F(Z,E)}_{\substack{\text{кулоновская}\\\text{поправка}}}\, \underbrace{\sqrt{E^2+2m_eE}}_{p_e}\, \underbrace{(E+m_e)}_{E_e}\, \underbrace{(E_0-E)}_{E_\nu}\, \underbrace{\sqrt{(E_0-E)^2-m_\nu^2}}_{p_\nu}\, \Theta(E_0-E-m_\nu), \]

где \(E\) — кинетическая энергия электрона, \(E_0\) - максимально возможная энергия электрона при условии \(m_\nu=0\).

viewof fermiMass = Inputs.range([0, 3], {
  value: 1,
  step: 0.1,
  label: html`
    <span class="spectrum-slider-label">
      ${tex`m_\nu,\ \text{эВ}`}
    </span>
  `
})

fermiElectronMass = 511000
fermiEndpoint = 18575
fermiWindow = 3

fermiSpectrum = (energy, mass) => {
  const neutrinoEnergy = fermiEndpoint - energy;
  if (neutrinoEnergy < mass) return 0;
  const electronMomentum = Math.sqrt(
    energy * energy + 2 * fermiElectronMass * energy
  );
  const neutrinoMomentum = Math.sqrt(Math.max(
    0,
    neutrinoEnergy * neutrinoEnergy - mass * mass
  ));
  return electronMomentum
    * (energy + fermiElectronMass)
    * neutrinoEnergy
    * neutrinoMomentum;
}

fermiIntegrate = (lower, upper, mass, steps = 1000) => {
  if (upper <= lower) return 0;
  const step = (upper - lower) / steps;
  let sum = (
    fermiSpectrum(lower, mass)
    + fermiSpectrum(upper, mass)
  ) / 2;
  for (let i = 1; i < steps; i += 1) {
    sum += fermiSpectrum(lower + i * step, mass);
  }
  return sum * step;
}

fermiNorm = fermiSpectrum(fermiEndpoint - fermiWindow, 0)
fermiTotalIntegral = fermiIntegrate(0, fermiEndpoint, 0, 8000)
fermiShadedIntegral = fermiIntegrate(
  fermiEndpoint - fermiMass,
  fermiEndpoint,
  0,
  400
)
fermiShadedFraction = fermiShadedIntegral / fermiTotalIntegral
fermiFractionExponent = fermiShadedFraction === 0
  ? 0
  : Math.floor(Math.log10(fermiShadedFraction))
fermiFractionMantissa = fermiShadedFraction === 0
  ? "0"
  : (
    fermiShadedFraction / 10 ** fermiFractionExponent
  ).toFixed(2)

fermiX = Array.from({length: 501}, (_, i) =>
  -fermiWindow + fermiWindow * i / 500
)
fermiMassless = fermiX.map(x => ({
  x,
  y: fermiSpectrum(fermiEndpoint + x, 0) / fermiNorm
}))
fermiMassive = fermiX
  .filter(x => -x >= fermiMass)
  .map(x => ({
    x,
    y: fermiSpectrum(fermiEndpoint + x, fermiMass) / fermiNorm
  }))
fermiShaded = fermiMassless.filter(d => d.x >= -fermiMass)

fermiPlot = Plot.plot({
  width: 1120,
  height: 300,
  marginTop: 18,
  marginRight: 25,
  marginBottom: 45,
  marginLeft: 72,
  style: {
    background: "#ffffff",
    color: "#111111",
    fontSize: "20px"
  },
  x: {
    axis: "bottom",
    label: null,
    domain: [-fermiWindow, 0],
    ticks: 6,
    grid: true
  },
  y: {
    axis: "left",
    label: null,
    domain: [0, 1.05],
    ticks: 5,
    grid: true,
    tickFormat: value => value.toFixed(1)
  },
  marks: [
    Plot.areaY(fermiShaded, {
      x: "x",
      y: "y",
      fill: "#999999",
      fillOpacity: 0.65
    }),
    Plot.ruleY([0], {
      stroke: "#111111",
      strokeWidth: 1.5
    }),
    Plot.line(fermiMassless, {
      x: "x",
      y: "y",
      stroke: "#4ea1ff",
      strokeWidth: 4
    }),
    Plot.line(fermiMassive, {
      x: "x",
      y: "y",
      stroke: "#ffb347",
      strokeWidth: 4
    }),
    Plot.ruleX([-fermiMass], {
      stroke: "#ffb347",
      strokeDasharray: "7,5",
      strokeWidth: 2.5
    }),
    Plot.frame({stroke: "#111111"})
  ]
})

html`
<div class="spectrum-panel">
  <div class="spectrum-legend">
    <span>
      <i class="spectrum-swatch spectrum-swatch-massless"></i>
      ${tex`m_\nu=0`}
    </span>
    <span>
      <i class="spectrum-swatch spectrum-swatch-massive"></i>
      ${tex`m_\nu=${fermiMass.toFixed(1)}\ \mathrm{eV}`}
    </span>
  </div>
  <div class="spectrum-plot-row">
    <div class="spectrum-y-label">
      ${tex`\dfrac{d\Gamma}{dE}\;(\mathrm{a.u.})`}
    </div>
    <div class="spectrum-plot-host">
      ${fermiPlot}
      <div class="spectrum-integral-overlay">
        <span>
          ${tex`\dfrac{\int_{E_0-m_\nu}^{E_0}(d\Gamma/dE)\,dE}
          {\int_0^{E_0}(d\Gamma/dE)\,dE}`}
        </span>
        <span>
          ≈ ${fermiFractionMantissa}
          ${fermiShadedFraction === 0
            ? ""
            : html`× 10<sup>${fermiFractionExponent}</sup>`}
        </span>
      </div>
    </div>
  </div>
  <div class="spectrum-x-label">
    ${tex`E-E_0\;(\mathrm{eV})`}
  </div>
  <div class="spectrum-summary">
    <span>${tex`E_0=18.575\ \mathrm{keV}`}</span>
    <span>${tex`E_{\max}=E_0-m_\nu`}</span>
  </div>
</div>`

Функция Ферми \(F(Z,E;A)\)

• Конечное состояние
• Кулоновская фокусировка
• Спектры \(\beta^-\) и \(\beta^+\)
• Релятивистский вид
• Причинность

Для свободных частиц удобно вычислить спектр с плоскими волнами. Для нейтрино это хорошее приближение, но заряженный лептон рождается внутри кулоновского поля дочернего ядра. Поэтому плоская электронная волна не является состоянием конечного гамильтониана:

\[ \left[ \boldsymbol\alpha\cdot\mathbf p+\beta m_e+V_C(r) \right]\psi^{(-)}_{E_e\mathbf p}(\mathbf r) =E_e\psi^{(-)}_{E_e\mathbf p}(\mathbf r), \qquad V_C(r)\simeq-\frac{Z_d\alpha}{r}. \]

Для разрешённого перехода, \(p_eR\ll1\) и \(p_\nu R\ll1\), слабая вершина зондирует электронную волну в области ядра:

\[ \mathcal M_{fi}\simeq \psi_{E_e\mathbf p}^{(-)*}(R)\,\mathcal M_{\mathrm{nucl}}, \qquad \boxed{ F(Z_d,E_e;A)= \frac{|\psi_C^{(-)}(R)|^2}{|\psi_{\mathrm{pw}}(R)|^2} }. \]

То есть простой результат не выбрасывают, а умножают на вычисляемое отношение плотностей волны в области слабой вершины:

\[ \boxed{ \frac{d\Gamma_C}{dE_e} =F(Z_d,E_e;A)\frac{d\Gamma_{\mathrm{pw}}}{dE_e} }. \]

\(F\) — не феноменологическая «потеря энергии после распада»: она исправляет матричный элемент, а не фазовое пространство нейтрино.

Обратим картину во времени: медленный электрон с заданным асимптотическим импульсом падает на положительное ядро. Притяжение повышает плотность его волны у ядра. Поэтому для \(\beta^-\)-распада

\[ \eta=\frac{Z_d\alpha}{\beta_e}, \qquad \boxed{ F_{\mathrm{NR}}(Z_d,E_e) =\frac{2\pi\eta}{1-e^{-2\pi\eta}}>1 }, \qquad \beta_e=\frac{p_e}{E_e}. \]

При \(\beta_e\ll1\) имеем \(F_{\mathrm{NR}}\simeq2\pi Z_d\alpha/\beta_e\): это кулоновское усиление Зоммерфельда. Для \(\beta^+\) знак потенциала меняется, волна дефокусируется и \(F<1\).

Для разрешённого перехода и \(m_\nu=0\):

\[ \frac{d\Gamma_\mp}{dK}\propto F(\pm Z_d,E_e;A)\,p_eE_e(E_0-K)^2, \qquad E_e=K+m_e. \]

viewof fermiCompareParameters = {
  const control = html`<div class="fermi-compare-controls">
    <label>
      <span>${tex`Z_d`}</span>
      <output></output>
      <input name="charge" type="range"
        min="1" max="60" step="1" value="29">
    </label>
    <label>
      <span>${tex`A`}</span>
      <output></output>
      <input name="massNumber" type="range"
        min="2" max="160" step="1" value="64">
    </label>
    <label>
      <span>${tex`E_0,\ \text{МэВ}`}</span>
      <output></output>
      <input name="endpoint" type="range"
        min="0.5" max="4" step="0.1" value="2">
    </label>
  </div>`;

  const inputs = [...control.querySelectorAll("input")];
  const outputs = [...control.querySelectorAll("output")];

  function update(dispatch = true) {
    control.value = {
      charge: Number(inputs[0].value),
      massNumber: Number(inputs[1].value),
      endpoint: Number(inputs[2].value)
    };
    outputs[0].textContent = String(control.value.charge);
    outputs[1].textContent = String(control.value.massNumber);
    outputs[2].textContent = control.value.endpoint.toFixed(1).replace(".", ",");
    if (dispatch) {
      control.dispatchEvent(new Event("input", {bubbles: true}));
    }
  }

  inputs.forEach(input => input.addEventListener("input", () => update()));
  update(false);
  return control;
}

fermiCompareAlpha = 1 / 137.035999084
fermiCompareElectronMass = 510.99895
fermiCompareHbarC = 197326.9804
fermiCompareLanczos = [
  676.5203681218851,
  -1259.1392167224028,
  771.3234287776531,
  -176.6150291621406,
  12.507343278686905,
  -0.13857109526572012,
  9.984369578019572e-6,
  1.5056327351493116e-7
]

fermiCompareComplexAdd = (a, b) => ({
  re: a.re + b.re,
  im: a.im + b.im
})

fermiCompareComplexMultiply = (a, b) => ({
  re: a.re * b.re - a.im * b.im,
  im: a.re * b.im + a.im * b.re
})

fermiCompareRealDivide = (a, b) => {
  const denominator = b.re * b.re + b.im * b.im;
  return {
    re: a * b.re / denominator,
    im: -a * b.im / denominator
  };
}

fermiCompareComplexLog = z => ({
  re: Math.log(Math.hypot(z.re, z.im)),
  im: Math.atan2(z.im, z.re)
})

fermiCompareLogGamma = z => {
  const shifted = {re: z.re - 1, im: z.im};
  let series = {re: 0.9999999999998099, im: 0};
  fermiCompareLanczos.forEach((coefficient, index) => {
    series = fermiCompareComplexAdd(
      series,
      fermiCompareRealDivide(coefficient, {
        re: shifted.re + index + 1,
        im: shifted.im
      })
    );
  });
  const t = {re: shifted.re + 7.5, im: shifted.im};
  const power = fermiCompareComplexMultiply(
    {re: shifted.re + 0.5, im: shifted.im},
    fermiCompareComplexLog(t)
  );
  return fermiCompareComplexAdd(
    {re: 0.5 * Math.log(2 * Math.PI) - t.re, im: -t.im},
    fermiCompareComplexAdd(power, fermiCompareComplexLog(series))
  );
}

fermiCompareFactor = (charge, massNumber, kineticEnergy, leptonSign) => {
  const totalEnergy = kineticEnergy + fermiCompareElectronMass;
  const momentum = Math.sqrt(
    kineticEnergy * (kineticEnergy + 2 * fermiCompareElectronMass)
  );
  const gamma = Math.sqrt(1 - (charge * fermiCompareAlpha) ** 2);
  const eta = leptonSign * charge * fermiCompareAlpha
    * totalEnergy / momentum;
  const radius = 1.2 * massNumber ** (1 / 3) / fermiCompareHbarC;
  const logGammaReal = fermiCompareLogGamma({
    re: 2 * gamma + 1,
    im: 0
  }).re;
  const logGammaComplex = fermiCompareLogGamma({
    re: gamma,
    im: eta
  }).re;
  const logFactor = Math.log(2 * (1 + gamma))
    - 2 * logGammaReal
    + 2 * (gamma - 1) * Math.log(2 * momentum * radius)
    + Math.PI * eta
    + 2 * logGammaComplex;
  return Math.exp(logFactor);
}

fermiCompareEndpoint = 1000 * fermiCompareParameters.endpoint

fermiComparePlaneRate = kineticEnergy => {
  const totalEnergy = kineticEnergy + fermiCompareElectronMass;
  const momentum = Math.sqrt(
    kineticEnergy * (kineticEnergy + 2 * fermiCompareElectronMass)
  );
  const neutrinoEnergy = fermiCompareEndpoint - kineticEnergy;
  return momentum * totalEnergy * neutrinoEnergy * neutrinoEnergy;
}

fermiCompareKineticEnergies = Array.from({length: 601}, (_, index) =>
  Math.max(0.05, fermiCompareEndpoint * index / 600)
).filter(energy => energy < fermiCompareEndpoint)

fermiCompareRaw = leptonSign => fermiCompareKineticEnergies.map(energy => {
  const plane = fermiComparePlaneRate(energy);
  const factor = fermiCompareFactor(
    fermiCompareParameters.charge,
    fermiCompareParameters.massNumber,
    energy,
    leptonSign
  );
  return {energy: energy / 1000, plane, corrected: factor * plane};
})

fermiCompareNormalize = data => {
  const planeMaximum = Math.max(...data.map(d => d.plane));
  const correctedMaximum = Math.max(...data.map(d => d.corrected));
  return data.map(d => ({
    energy: d.energy,
    plane: d.plane / planeMaximum,
    corrected: d.corrected / correctedMaximum
  }));
}

fermiCompareMinusData = fermiCompareNormalize(fermiCompareRaw(1))
fermiComparePlusData = fermiCompareNormalize(fermiCompareRaw(-1))

fermiComparePlot = (data, color) => Plot.plot({
  width: 840,
  height: 370,
  marginTop: 10,
  marginRight: 18,
  marginBottom: 50,
  marginLeft: 62,
  style: {
    background: "#ffffff",
    color: "#111111",
    fontSize: "22px"
  },
  x: {
    axis: "bottom",
    label: "K (МэВ)",
    domain: [0, fermiCompareParameters.endpoint],
    ticks: 5,
    grid: true
  },
  y: {
    axis: "left",
    label: null,
    domain: [0, 1.05],
    ticks: 5,
    grid: true,
    tickFormat: value => value.toFixed(1)
  },
  marks: [
    Plot.areaY(data, {
      x: "energy",
      y: "corrected",
      fill: color,
      fillOpacity: 0.14
    }),
    Plot.line(data, {
      x: "energy",
      y: "plane",
      stroke: "#777777",
      strokeWidth: 2.5,
      strokeDasharray: "7,5"
    }),
    Plot.line(data, {
      x: "energy",
      y: "corrected",
      stroke: color,
      strokeWidth: 4
    }),
    Plot.frame({stroke: "#111111"})
  ]
})

fermiCompareMinusPlot = fermiComparePlot(
  fermiCompareMinusData,
  "#4ea1ff"
)
fermiComparePlusPlot = fermiComparePlot(
  fermiComparePlusData,
  "#ffb347"
)

fermiCompareProbeEnergy = Math.min(10, 0.02 * fermiCompareEndpoint)
fermiCompareMinusProbe = fermiCompareFactor(
  fermiCompareParameters.charge,
  fermiCompareParameters.massNumber,
  fermiCompareProbeEnergy,
  1
)
fermiComparePlusProbe = fermiCompareFactor(
  fermiCompareParameters.charge,
  fermiCompareParameters.massNumber,
  fermiCompareProbeEnergy,
  -1
)

html`<div class="fermi-compare-grid">
  <div class="fermi-compare-panel">
    <div class="fermi-compare-title">
      ${tex`\beta^-:`} притяжение к ядру
    </div>
    <div class="spectrum-plot-host">${fermiCompareMinusPlot}</div>
    <div class="fermi-compare-readout">
      ${tex`F(+Z_d,K=${fermiCompareProbeEnergy.toFixed(0)}\,\mathrm{keV})
      =${fermiCompareMinusProbe.toFixed(2)}`}
    </div>
  </div>
  <div class="fermi-compare-panel">
    <div class="fermi-compare-title">
      ${tex`\beta^+:`} отталкивание от ядра
    </div>
    <div class="spectrum-plot-host">${fermiComparePlusPlot}</div>
    <div class="fermi-compare-readout">
      ${tex`F(-Z_d,K=${fermiCompareProbeEnergy.toFixed(0)}\,\mathrm{keV})
      =${fermiComparePlusProbe.toFixed(2)}`}
    </div>
  </div>
</div>
<div class="fermi-compare-note">
  <span class="fermi-line-key fermi-line-key-plane"></span>
  плоская волна;
  <span class="fermi-line-key" style="color:#b8d9ff"></span>
  с ${tex`F(\pm Z_d,E_e;A)`}.<br>
  Каждая кривая нормирована на свой максимум; одинаковые параметры выделяют
  чисто эффект знака заряда.
</div>`

Для точечного ядра решение уравнения Дирака даёт

\[ \boxed{ F_0(Z_d,E_e;R)= \frac{2(1+\gamma)}{\Gamma(2\gamma+1)^2} (2p_eR)^{2(\gamma-1)} e^{\pi\eta}|\Gamma(\gamma+i\eta)|^2 }, \]

\[ \gamma=\sqrt{1-(Z_d\alpha)^2}, \qquad \eta=\frac{Z_d\alpha E_e}{p_e}, \qquad R\simeq r_0A^{1/3}. \]

Поэтому краткая запись \(F(Z,A)\) скрывает энергетическую зависимость: фактически \(F=F(Z_d,E_e;R(A))\). В точном расчёте используют конечное распределение заряда ядра, экранировку и радиационные поправки.

Термин «поправка на конечное состояние» иногда иллюстрируют так: электрон сначала вылетел с одной энергией, затем затормозился и пришёл на бесконечность с меньшей. Такая последовательная картина вводит в заблуждение: свободного электрона «до поправки» не было.

Кулоновское конечное состояние сразу задаётся асимптотической энергией \(E_e\). Точно и в квазиклассическом пределе соответственно:

\[ H_C\psi_{E_e}=E_e\psi_{E_e}, \qquad E_e=\sqrt{\boldsymbol\pi^2(r)+m_e^2}+V_C(r)=\mathrm{const}, \qquad V_C(\infty)=0. \]

Для \(\beta^-\) имеем \(V_C<0\): вблизи ядра локальная кинетическая энергия больше и убывает при удалении, но полная \(E_e\) остаётся той же. Для \(\beta^+\) знак эффекта противоположен.

В \(S\)-матрице эта же асимптотическая \(E_e\) входит в закон сохранения энергии:

\[ \int dt\,e^{i(E_f+E_e+E_\nu-E_i)t} =2\pi\delta(E_i-E_f-E_e-E_\nu). \]

Поэтому \(F(Z_d,E_e)\) меняет амплитуду и вероятности разных разбиений энергии, но ничего не перераспределяет «после распада». У трития \(F\) входит в медленный множитель \(C(E)\) и не сдвигает границу \(E_{\max}=E_0-m_\nu\).

\(F\) исправляет конечное состояние, а не энергию уже испущенных частиц.

Hayen et al., Rev. Mod. Phys. 90, 015008 (2018) · Hill, Plestid, Phys. Rev. Lett. 133, 021803 (2024)

Экспериментальные требования

Нужны высокая статистика у конца спектра и малое, хорошо известное \(\sigma_E\).

\[ \begin{aligned} \frac{d\Gamma_{\mathrm{rec}}}{dE_{\mathrm{rec}}} &= \int_0^{E_0-m_\nu} R(E_{\mathrm{rec}}\mid E;\sigma_E)\, \frac{d\Gamma}{dE}\,dE, \\ R(E_{\mathrm{rec}}\mid E;\sigma_E) &= \frac{1}{\sqrt{2\pi}\sigma_E} \exp\left[ -\frac{(E_{\mathrm{rec}}-E)^2}{2\sigma_E^2} \right]. \end{aligned} \]

viewof resolutionSigma = Inputs.range([0, 2], {
  value: 0.5,
  step: 0.1,
  label: html`
    <span class="spectrum-slider-label">
      ${tex`\sigma_E,\ \text{эВ}`}
    </span>
  `
})

resolutionMass = 1
resolutionXMin = -3
resolutionXMax = 1.5
resolutionGaussianNorm = Math.sqrt(2 * Math.PI)

resolutionConvolvedSpectrum = (xReco, mass, sigma) => {
  if (sigma === 0) {
    return fermiSpectrum(fermiEndpoint + xReco, mass) / fermiNorm;
  }

  const lower = Math.max(-fermiEndpoint, xReco - 6 * sigma);
  const upper = Math.min(-mass, xReco + 6 * sigma);
  if (upper <= lower) return 0;

  const steps = 240;
  const step = (upper - lower) / steps;
  const integrand = xTrue => {
    const pull = (xReco - xTrue) / sigma;
    const response = Math.exp(-0.5 * pull * pull)
      / (resolutionGaussianNorm * sigma);
    return response
      * fermiSpectrum(fermiEndpoint + xTrue, mass)
      / fermiNorm;
  };

  let sum = (integrand(lower) + integrand(upper)) / 2;
  for (let i = 1; i < steps; i += 1) {
    sum += integrand(lower + i * step);
  }
  return sum * step;
}

resolutionX = Array.from({length: 501}, (_, i) =>
  resolutionXMin
    + (resolutionXMax - resolutionXMin) * i / 500
)

resolutionData = resolutionX.map(x => ({
  x,
  massless: resolutionConvolvedSpectrum(x, 0, resolutionSigma),
  massive: resolutionConvolvedSpectrum(
    x,
    resolutionMass,
    resolutionSigma
  )
}))

resolutionPlot = Plot.plot({
  width: 1120,
  height: 300,
  marginTop: 18,
  marginRight: 25,
  marginBottom: 45,
  marginLeft: 72,
  style: {
    background: "#ffffff",
    color: "#111111",
    fontSize: "20px"
  },
  x: {
    axis: "bottom",
    label: null,
    domain: [resolutionXMin, resolutionXMax],
    ticks: 7,
    grid: true
  },
  y: {
    axis: "left",
    label: null,
    domain: [0, 1.5],
    ticks: 6,
    grid: true,
    tickFormat: value => value.toFixed(1)
  },
  marks: [
    Plot.areaY(resolutionData, {
      x: "x",
      y1: "massive",
      y2: "massless",
      fill: "#999999",
      fillOpacity: 0.55
    }),
    Plot.ruleY([0], {
      stroke: "#111111",
      strokeWidth: 1.5
    }),
    Plot.line(resolutionData, {
      x: "x",
      y: "massless",
      stroke: "#4ea1ff",
      strokeWidth: 4
    }),
    Plot.line(resolutionData, {
      x: "x",
      y: "massive",
      stroke: "#ffb347",
      strokeWidth: 4
    }),
    Plot.ruleX([0], {
      stroke: "#4ea1ff",
      strokeDasharray: "7,5",
      strokeWidth: 2.5
    }),
    Plot.ruleX([-resolutionMass], {
      stroke: "#ffb347",
      strokeDasharray: "7,5",
      strokeWidth: 2.5
    }),
    Plot.frame({stroke: "#111111"})
  ]
})

html`
<div class="spectrum-panel">
  <div class="spectrum-legend">
    <span>
      <i class="spectrum-swatch spectrum-swatch-massless"></i>
      ${tex`m_\nu=0`}
    </span>
    <span>
      <i class="spectrum-swatch spectrum-swatch-massive"></i>
      ${tex`m_\nu=1\ \text{эВ}`}
    </span>
  </div>
  <div class="spectrum-plot-row">
    <div class="spectrum-y-label">
      ${tex`\dfrac{d\Gamma_{\mathrm{rec}}}{dE_{\mathrm{rec}}}
      \;(\text{отн. ед.})`}
    </div>
    <div class="spectrum-plot-host">
      ${resolutionPlot}
    </div>
  </div>
  <div class="spectrum-x-label">
    ${tex`E_{\mathrm{rec}}-E_0\;(\text{эВ})`}
  </div>
</div>`

Что измеряет \(\beta\)-спектр?

Масса, флэйвор и конечное состояние

• Состояния
• Почему сумма?
• Спектр
• Разрешение

Слабое взаимодействие рождает электронное антинейтрино:

\[ |\bar\nu_e\rangle=\sum_i V_{ei}|\bar\nu_i\rangle. \]

\(|\bar\nu_i\rangle\) — состояние с определённой массой \(m_i\); \(V_{ei}\) — элемент матрицы смешивания. В каждом массовом канале

\[ E_{\nu,i}^2=p_{\nu,i}^2+m_i^2. \]

Кинематический эксперимент чувствителен к массам \(m_i\), хотя частица рождается электронным антинейтрино.

Конечные состояния с разными массами ортогональны:

\[ \langle\bar\nu_j|\bar\nu_i\rangle=\delta_{ij}. \]

Нейтрино не регистрируется. После суммирования по ненаблюдаемому конечному состоянию интерференционные члены исчезают:

\[ \sum_i\left|V_{ei}\mathcal M_i\right|^2 =\sum_i|V_{ei}|^2|\mathcal M_i|^2. \]

Поэтому в \(\beta\)-спектре складываются вероятности, а не амплитуды.

Обозначим

\[ E_\nu=E_0-E, \qquad C(E)\propto F(Z,E)p_e(E+m_e). \]

Тогда

\[ \boxed{ \frac{d\Gamma}{dE} =C(E)\sum_i|V_{ei}|^2 E_\nu\sqrt{E_\nu^2-m_i^2}\, \Theta(E_\nu-m_i) }. \]

Каждое массовое состояние заканчивается при \(E_{\max,i}=E_0-m_i\).

Если энергетическое разрешение лучше разделения масс, спектр содержит несколько изломов:

\[ \sigma_E\lesssim |m_i-m_j|. \]

Для трёх лёгких нейтрино \(|m_i-m_j|\lesssim5\cdot10^{-2}~\mathrm{эВ}\), что намного меньше разрешения современных тритиевых экспериментов.

Отдельные пороги сливаются в один эффективный конец спектра.

Разрешённые массовые пороги

В учебном примере массы искусственно увеличены до кэВ, чтобы пороги были видны.

resolvedEndpoint = 18.575
resolvedXMin = -12.5
resolvedXMax = -0.05

viewof resolvedMasses = {
  const control = html`<div class="resolved-mass-controls">
    <label>
      <span>${tex`m_1,\ \text{кэВ}`}</span>
      <output></output>
      <input name="mass1" type="range"
        min="0" max="12" step="0.5" value="0">
    </label>
    <label>
      <span>${tex`m_2,\ \text{кэВ}`}</span>
      <output></output>
      <input name="mass2" type="range"
        min="0" max="12" step="0.5" value="0">
    </label>
    <label>
      <span>${tex`m_3,\ \text{кэВ}`}</span>
      <output></output>
      <input name="mass3" type="range"
        min="0" max="12" step="0.5" value="10">
    </label>
  </div>`;

  const inputs = [...control.querySelectorAll("input")];
  const outputs = [...control.querySelectorAll("output")];

  function update(dispatch = true) {
    control.value = inputs.map(input => Number(input.value));
    outputs.forEach((output, i) => {
      output.textContent = String(control.value[i]).replace(".", ",");
    });
    if (dispatch) {
      control.dispatchEvent(new Event("input", {bubbles: true}));
    }
  }

  inputs.forEach(input => {
    input.addEventListener("input", () => update());
  });
  update(false);
  return control;
}

resolvedWeights = [1 / 3, 1 / 3, 1 / 3]

resolvedPhaseSpace = (x, mass) => {
  const neutrinoEnergy = -x;
  if (neutrinoEnergy < mass) return 0;
  return neutrinoEnergy * Math.sqrt(
    neutrinoEnergy * neutrinoEnergy - mass * mass
  );
}

resolvedRate = x => resolvedMasses.reduce(
  (sum, mass, i) =>
    sum + resolvedWeights[i] * resolvedPhaseSpace(x, mass),
  0
)

resolvedNorm = resolvedRate(resolvedXMin)
resolvedX = Array.from({length: 801}, (_, i) =>
  resolvedXMin + (resolvedXMax - resolvedXMin) * i / 800
)

resolvedData = resolvedX.map(x => ({
  x,
  y: resolvedRate(x) / resolvedNorm
}))

resolvedComponents = resolvedMasses.map((mass, i) =>
  resolvedX
    .map(x => ({
      x,
      y: resolvedWeights[i] * resolvedPhaseSpace(x, mass) / resolvedNorm
    }))
    .filter(d => d.y > 0)
)

resolvedThresholds = [...new Set(
  resolvedMasses
    .filter(mass => mass > 0)
    .map(mass => Number(mass.toFixed(1)))
)]

resolvedSuperscript = value => {
  const symbols = {
    "-": "⁻",
    "0": "⁰",
    "1": "¹",
    "2": "²",
    "3": "³",
    "4": "⁴",
    "5": "⁵",
    "6": "⁶",
    "7": "⁷",
    "8": "⁸",
    "9": "⁹"
  };
  return String(value)
    .split("")
    .map(character => symbols[character])
    .join("");
}

resolvedPowerLabel = value => {
  const exponent = Math.log10(value);
  if (Math.abs(exponent - Math.round(exponent)) > 1e-8) return "";
  return exponent === 0
    ? "1"
    : `10${resolvedSuperscript(Math.round(exponent))}`;
}

resolvedPlot = Plot.plot({
  width: 1040,
  height: 270,
  marginTop: 18,
  marginRight: 25,
  marginBottom: 45,
  marginLeft: 82,
  style: {
    background: "#ffffff",
    color: "#111111",
    fontSize: "20px"
  },
  x: {
    axis: "bottom",
    label: null,
    domain: [resolvedXMin, 0],
    ticks: 7,
    grid: true
  },
  y: {
    axis: "left",
    label: null,
    type: "log",
    domain: [1e-3, 1.1],
    ticks: 7,
    grid: true,
    tickFormat: resolvedPowerLabel
  },
  marks: [
    ...resolvedComponents.map(component => Plot.line(component, {
      x: "x",
      y: "y",
      stroke: "#777777",
      strokeWidth: 2,
      strokeDasharray: "6,5",
      clip: true
    })),
    Plot.line(resolvedData, {
      x: "x",
      y: "y",
      stroke: "#4ea1ff",
      strokeWidth: 4,
      clip: true
    }),
    Plot.ruleX(resolvedThresholds.map(mass => -mass), {
      stroke: "#ffb347",
      strokeDasharray: "7,5",
      strokeWidth: 2.5
    }),
    Plot.frame({stroke: "#111111"})
  ]
})

html`
<div class="spectrum-panel">
  <div class="spectrum-legend">
    <span>
      <i class="spectrum-swatch spectrum-swatch-massless"></i>
      сумма
    </span>
    <span>
      <i class="spectrum-swatch" style="background:#777777"></i>
      вклады ${tex`m_i`}
    </span>
    <span>
      ${tex`|V_{ei}|^2=\frac13`}
    </span>
  </div>
  <div class="spectrum-plot-row">
    <div class="spectrum-y-label">
      ${tex`\dfrac{1}{C(E)}\dfrac{d\Gamma}{dE}\;(\text{отн. ед.})`}
    </div>
    <div class="spectrum-plot-host">${resolvedPlot}</div>
  </div>
  <div class="spectrum-x-label">${tex`E-E_0\;(\text{кэВ})`}</div>
</div>`

Эффективная масса \(m_\beta\)

Если пороги не разрешаются и \(E_\nu\gg m_i\), то

\[ \begin{aligned} \sum_i|V_{ei}|^2\sqrt{E_\nu^2-m_i^2} &\simeq E_\nu\sum_i|V_{ei}|^2 \left(1-\frac{m_i^2}{2E_\nu^2}\right) \\ &=E_\nu\left[ 1-\frac{1}{2E_\nu^2}\sum_i|V_{ei}|^2m_i^2 \right]. \end{aligned} \]

Сравнивая это с

\[ \sqrt{E_\nu^2-m_\beta^2} \simeq E_\nu\left(1-\frac{m_\beta^2}{2E_\nu^2}\right), \]

получаем

\[ \boxed{m_\beta^2=\sum_i|V_{ei}|^2m_i^2}. \]

График Кури

Для разрешённого перехода уберём медленно меняющиеся множители:

\[ K(E)\equiv \left[ \frac{d\Gamma/dE}{F(Z,E)p_e(E+m_e)} \right]^{1/2}. \]

При \(m_\beta=0\) получаем прямую \(K(E)=E_0-E\); ненулевая масса искривляет её и сдвигает конец.

kurieMass = 1
kurieX = Array.from({length: 501}, (_, i) => -3 + 3 * i / 500)

kurieValue = (x, mass) => {
  const neutrinoEnergy = -x;
  if (neutrinoEnergy < mass) return null;
  return Math.sqrt(
    neutrinoEnergy
    * Math.sqrt(neutrinoEnergy * neutrinoEnergy - mass * mass)
  );
}

kurieMassless = kurieX.map(x => ({
  x,
  y: kurieValue(x, 0)
}))

kurieMassive = kurieX
  .filter(x => -x >= kurieMass)
  .map(x => ({
    x,
    y: kurieValue(x, kurieMass)
  }))

kuriePlot = Plot.plot({
  width: 1040,
  height: 310,
  marginTop: 18,
  marginRight: 25,
  marginBottom: 45,
  marginLeft: 65,
  style: {
    background: "#ffffff",
    color: "#111111",
    fontSize: "20px"
  },
  x: {
    axis: "bottom",
    label: null,
    domain: [-3, 0],
    ticks: 6,
    grid: true
  },
  y: {
    axis: "left",
    label: null,
    domain: [0, 3.1],
    ticks: 6,
    grid: true,
    tickFormat: value => value.toFixed(1)
  },
  marks: [
    Plot.ruleY([0], {
      stroke: "#111111",
      strokeWidth: 1.5
    }),
    Plot.line(kurieMassless, {
      x: "x",
      y: "y",
      stroke: "#4ea1ff",
      strokeWidth: 4
    }),
    Plot.line(kurieMassive, {
      x: "x",
      y: "y",
      stroke: "#ffb347",
      strokeWidth: 4
    }),
    Plot.ruleX([-kurieMass], {
      stroke: "#ffb347",
      strokeDasharray: "7,5",
      strokeWidth: 2.5
    }),
    Plot.frame({stroke: "#111111"})
  ]
})

html`
<div class="spectrum-panel">
  <div class="spectrum-legend">
    <span>
      <i class="spectrum-swatch spectrum-swatch-massless"></i>
      ${tex`m_\beta=0`}
    </span>
    <span>
      <i class="spectrum-swatch spectrum-swatch-massive"></i>
      ${tex`m_\beta=1\ \text{эВ}`}
    </span>
  </div>
  <div class="spectrum-plot-row">
    <div class="spectrum-y-label">${tex`K(E)\;(\text{отн. ед.})`}</div>
    <div class="spectrum-plot-host">${kuriePlot}</div>
  </div>
  <div class="spectrum-x-label">${tex`E-E_0\;(\text{эВ})`}</div>
</div>`

Кури, не Кюри График предложил Франц Ньюэлл Деверё Кури (Franz N. D. Kurie).

Кюри — Мария.

Конечные возбуждённые состояния

После распада молекула может оказаться в состоянии \(j\) с энергией возбуждения \(V_j\) и вероятностью \(W_j\):

\[ E_{\nu,j}=E_0-E-V_j, \qquad \sum_jW_j=1. \]

Тогда

\[ \frac{d\Gamma}{dE} =C(E)\sum_jW_j\sum_i|V_{ei}|^2 E_{\nu,j}\sqrt{E_{\nu,j}^2-m_i^2}\, \Theta(E_{\nu,j}-m_i). \]

При неразрешённых массовых порогах

\[ \frac{d\Gamma}{dE} \simeq C(E)\sum_jW_j E_{\nu,j}\sqrt{E_{\nu,j}^2-m_\beta^2}\, \Theta(E_{\nu,j}-m_\beta). \]

M. Kleesiek et al., EPJ C 79, 204 (2019), Fig. 3, CC BY 4.0.

Тритий

Почему выбран тритий?

• Распад
• Цена статистики
• Атом или молекула?

\[ {}^3\mathrm H \to{}^3\mathrm{He}^{+}+e^-+\bar\nu_e, \qquad E_0\simeq18.6~\mathrm{кэВ}. \]

• малый \(E_0\): относительная доля событий у конца велика;
• сверхразрешённый переход: ядерный матричный элемент почти не меняет форму;
• \(T_{1/2}=12.32\) года: высокая удельная активность и стабильный источник;
• лёгкая система: отдача и молекулярные состояния точно вычисляются.

У конца разрешённого спектра при \(m_\beta=0\)

\[ \frac{d\Gamma}{dE}\propto(E_0-E)^2. \]

Поэтому доля распадов в последнем интервале \(\Delta E\) оценивается как

\[ f(\Delta E) \simeq \frac{\int_{E_0-\Delta E}^{E_0}(E_0-E)^2dE} {\int_0^{E_0}(E_0-E)^2dE} =\left(\frac{\Delta E}{E_0}\right)^3. \]

Для \(\Delta E=1~\mathrm{эВ}\) это всего

\[ f\sim1.6\cdot10^{-13}. \]

В KATRIN используется молекулярный тритий:

\[ \mathrm T_2\to{}^3\mathrm{HeT}^{+}+e^-+\bar\nu_e. \]

Молекулу удобно хранить и непрерывно прокачивать, но дочерний ион получает вращательное, колебательное или электронное возбуждение.

Неизмеренная энергия \(V_j\) вычитается из энергии нейтрино:

\[ E_{\nu,j}=E_0-E-V_j. \]

Поэтому распределение конечных состояний входит непосредственно в модель спектра.

От 30 эВ к KATRIN

Что изменили эксперименты 1980-х?

• ИТЭФ
• Плёнка
• Проверки
• Две технологии

В эксперименте группы В. А. Любимова использовались

• твёрдый источник — тонкая плёнка тритированного валина;
• магнитный спектрометр Третьякова с высокой светосилой;
• измерение формы последних сотен электронвольт \(\beta\)-спектра.

В 1980 году группа сообщила

\[ m_{\bar\nu_e}\simeq30~\mathrm{эВ}. \]

Дефицит электронов у конца спектра интерпретировали как кинематический эффект массы нейтрино.

Электрон рождается на глубине \(z\) и вылетает под углом \(\theta\) к нормали. Его путь в веществе равен

\[ \ell=\frac{z}{\cos\theta}, \qquad E_{\mathrm{det}}=E-\Delta E(\ell). \]

Поэтому наблюдаемый спектр содержит свёртку с распределением потерь \(L\):

\[ S_{\mathrm{obs}}(E) =\int L(\Delta E)S_\beta(E+\Delta E)\,d\Delta E. \]

Неоднородность толщины, шероховатость и состав плёнки меняют \(L(\Delta E)\). Ошибка в этой функции искажает конец спектра и может имитировать массу.

Результат проверяли в Лос-Аламосе, Цюрихе, Майнце и Троицке. Масса около \(30~\mathrm{эВ}\) не подтвердилась.

Главный урок: одного энергетического разрешения недостаточно. Конец спектра искажают эффекты, похожие на массу:

\[ \text{потери энергии} +\text{конечные состояния} +\text{функция отклика}. \]

Источник и спектрометр необходимо калибровать и моделировать вместе.

Следующее поколение объединило

\[ \boxed{\text{безоконный газовый источник }\mathrm T_2} \qquad+\qquad \boxed{\text{MAC-E-фильтр}}. \]

Газовый источник устраняет подложку. MAC-E-фильтр сочетает большой телесный угол с суб-эВ энергетическим разрешением.

Эта комбинация была развита в Майнце и Троицке и масштабирована в KATRIN.

В. А. Любимов и др., Phys. Lett. B 94, 266 (1980) · G. Drexlin, C. Weinheimer, обзор KATRIN (2026)