Systematic derivation of perturbative unitarity bounds for any models

This paper introduces a universal algorithm called anyPUB that systematically derives perturbative unitarity bounds for any particle physics model by computing high-energy $2 \rightarrow 2$ scattering matrices, a method validated against existing literature and applied to derive new constraints for the minimal left-right symmetric and Pati-Salam models.

The Gist

Imagine you are an architect designing a new skyscraper. You have a blueprint (your physics model) with fancy new materials and strange shapes. Before you pour the concrete, you need to make sure the building won't collapse under its own weight or blow away in a storm. In the world of particle physics, the "storm" is high-energy collisions, and the "collapse" is a mathematical breakdown called a violation of unitarity.

This paper introduces a new, automated tool called anyPUB that acts like a super-smart structural engineer for these theoretical skyscrapers.

Here is the breakdown of what the paper does, using simple analogies:

1. The Problem: Too Many Variables, Too Much Math

Physicists love inventing new theories (called "Beyond the Standard Model" or BSM) to explain mysteries like dark matter. These theories often involve adding new particles and forces.

• The Analogy: Imagine trying to calculate the stress on a bridge made of 100 different types of steel, cables, and wood. If you try to do the math by hand, you might make a mistake, or it might take you 10 years.
• The Issue: When these new models get too complex, the math gets messy. Previous attempts to check if these models are "stable" (mathematically consistent) often resulted in wrong answers or were too difficult to finish.

2. The Solution: The "anyPUB" Algorithm

The author, Nico Benincasa, created a software package (a Mathematica script) named anyPUB.

• How it works: You feed the software the "recipe" for your new model (the list of particles and how they interact).
• The Magic: The software automatically:
  1. Imagines a high-speed collision between two particles (like two cars crashing at 99% the speed of light).
  2. Calculates the probability of what happens next.
  3. Breaks this massive, tangled calculation into smaller, manageable chunks (like sorting a giant pile of LEGO bricks into separate boxes by color).
  4. Finds the "tipping points" (eigenvalues) where the model would break.

3. The "Goldstone Boson" Shortcut

To make the math faster, the paper uses a famous physics trick called the Goldstone Boson Equivalence Theorem.

• The Analogy: Imagine you want to know how a heavy, armored tank behaves in a mud pit. Instead of driving the actual tank (which is slow and hard to analyze), you realize that at high speeds, the tank behaves exactly like a lightweight, fast sports car rolling through the same mud.
• In Physics: At very high energies, heavy particles behave like massless "ghost" particles (Goldstone bosons). This allows the software to ignore the heavy, complicated parts of the math and focus only on the simple "contact interactions" (the crash itself), making the calculation much easier.

4. The "Block-Diagonal" Trick

The biggest hurdle in these calculations is that the math matrix (a giant grid of numbers) is huge and messy.

• The Analogy: Imagine a giant jigsaw puzzle with 1,000 pieces mixed together. Trying to solve it all at once is impossible.
• The Fix: The software uses graph theory (a branch of math about connections) to realize that the puzzle actually consists of 20 separate, smaller puzzles that don't touch each other. It separates them (block-diagonalizes them). Now, instead of solving one giant puzzle, you just solve 20 tiny ones. This makes finding the answer (the eigenvalues) incredibly fast.

5. The Real-World Tests: Fixing Mistakes and Breaking New Ground

The author didn't just build the tool; they tested it on two specific, complex models:

A. The Minimal Left-Right Symmetric Model (MLRSM)

• The Situation: Scientists had previously tried to calculate the stability limits for this model and published a result with 64 different constraints (rules).
• The Discovery: The author ran the model through anyPUB. The software found that the previous result was wrong (due to a few typos in the original math and a missing "symmetry factor").
• The Result: The new, correct calculation showed there are actually only 21 distinct rules, and they are much simpler than anyone thought. It's like realizing a complex legal contract actually only has 21 clauses instead of 64, and they are written in plain English.

B. The Pati-Salam Model

• The Situation: This is a very popular model that tries to unify the forces of nature. No one had ever successfully calculated its stability limits before because the math was too hard.
• The Result: anyPUB cracked the code. It derived the stability constraints for the first time, finding 23 distinct rules. This is like finally building the blueprint for a bridge that everyone knew was possible but no one knew how to calculate.

6. Why Does This Matter?

These "unitarity bounds" act as a speed limit for the new theories.

• If a model predicts that particles interact too strongly, the math breaks, and the theory is invalid.
• The paper shows that these new theories force the "coupling constants" (how strongly particles talk to each other) to be very small.
• The Takeaway: If you want to build a new skyscraper (a new physics theory), you can't just make the beams arbitrarily thick. They have to be within a specific range, or the building collapses. anyPUB tells you exactly what that range is, saving physicists from wasting time on theories that are mathematically impossible.

Summary

In short, this paper provides a universal, automated calculator that checks if new physics theories are mathematically stable. It fixes old mistakes, solves problems that were previously too hard, and gives physicists a clear "green light" or "red light" on their new ideas. It turns a nightmare of algebra into a simple, automated process.

Technical Summary

Here is a detailed technical summary of the paper "Systematic derivation of perturbative unitarity bounds for any models" by Nico Benincasa.

1. Problem Statement

The discovery of the Higgs boson completed the Standard Model (SM), but the SM fails to explain phenomena such as dark matter, neutrino masses, and baryon asymmetry. Consequently, physicists study Beyond the Standard Model (BSM) theories, which often involve extended scalar sectors with numerous new parameters.

• The Challenge: Many BSM models introduce parameters weakly constrained by experiment. Theoretical consistency, specifically perturbative unitarity, is essential to constrain these parameters.
• The Bottleneck: Deriving perturbative unitarity bounds requires calculating the eigenvalues of the $2 \to 2$scattering matrix ($S$-matrix) in the high-energy limit. For models with complex gauge groups and large field representations (e.g., Left-Right Symmetric Models, Pati-Salam models), this calculation is algebraically tedious, prone to human error, and computationally intensive. Existing tools (like SARAH or BounDS) often struggle with large matrix dimensions or require specific gauge group assumptions.

2. Methodology

The author introduces a general, automated algorithm and a corresponding Mathematica package named anyPUB. The methodology relies on the Goldstone boson equivalence theorem, which states that at high energies ($s \to \infty$), the scattering amplitudes of longitudinal gauge bosons are equivalent to those of their corresponding Goldstone bosons. This allows the calculation to focus solely on the quartic scalar interactions.

The Algorithmic Workflow:

1. Input: The user provides the quartic scalar potential ($V_4$) expressed in terms of real scalar fields and specifies which couplings are real.
2. Scattering Matrix Construction (ScatteringMatrix):
   • The package extracts all real fields and constructs all possible unordered pairs and quartic combinations.
   • It computes the fourth derivative of $V_4$ with respect to these fields to determine the four-point vertices.
   • It constructs the full $S$-matrix, applying necessary symmetry factors (e.g., $1/\sqrt{2}$ for identical particles) and ensuring Hermiticity.
3. Block Diagonalization (MakeBlockDiagonal):
   • Instead of diagonalizing the massive full matrix, the package uses graph theory.
   • It converts the $S$-matrix into an adjacency matrix (where non-zero off-diagonal elements represent edges).
   • It identifies connected components (subgraphs) within this graph.
   • It permutes rows and columns to transform the $S$-matrix into a block-diagonal form, where each block corresponds to an irreducible subspace of the scattering states.
4. Eigenvalue Extraction (EigenvaluesScatteringMatrix):
   • Eigenvalues are computed for each irreducible block individually.
   • Analytical Approach: For smaller or sparse blocks, the package attempts to find eigenvalues analytically.
   • Advanced Algebraic Techniques: For larger blocks where direct diagonalization is difficult, the package employs:
     • MatrixMinimalPolynomial: To find the minimal polynomial of the block.
     • ReducedCharacteristicPolynomial: To divide out known eigenvalues.
     • ReducedPolynomialNewton: Uses Newton's identities to solve for remaining eigenvalues using power sums (traces) and elementary symmetric polynomials.
   • Numerical Approach: If analytical solutions are intractable, numerical eigenvalue extraction is performed.

3. Key Contributions

• Universal Applicability: Unlike previous tools restricted to specific gauge groups (e.g., $SU(2) \times U(1)$), anyPUB works for any gauge group and field representation (singlets, doublets, triplets, bi-doublets, etc.).
• Automation and Efficiency: The package automates the entire process from potential definition to eigenvalue extraction, significantly reducing the risk of human error in complex algebraic manipulations.
• Correction of Literature: The author demonstrates that the package can identify and correct errors in previously published unitarity bounds for specific models.
• First-Time Derivations: The framework successfully derives perturbative unitarity constraints for the Pati-Salam model for the first time.

4. Results and Applications

A. Minimal Left-Right Symmetric Model (MLRSM)

• Context: The MLRSM involves a gauge group $SU(3)_C \otimes SU(2)_L \otimes SU(2)_R \otimes U(1)_{B-L}$ with bi-doublet and triplet scalars.
• Previous Work: A study by Mondal et al. [22] claimed 64 independent constraints.
• anyPUB Findings:
  • The package generated a $210 \times 210$$S$-matrix, which decomposed into 22 blocks.
  • It identified only 21 distinct eigenvalues, contradicting the 64 found in [22].
  • Error Identification: The discrepancy was traced to errors in the reference paper:
    1. Incorrect definition of the conjugate field $\tilde{\Phi}$ (missing complex conjugation).
    2. Incorrect trace terms in the potential ($\lambda_9$ and $\lambda_{12}$ terms).
    3. Missing symmetry factors in the $S$-matrix construction.
    4. Mixing of states with different electric charges.
  • Parameter Space: The derived bounds constrain the quartic couplings to be small ($|\lambda_u| < 0.7$, $|\lambda_M| < 0.8$), implying heavy scalar masses $M \lesssim 1.25 v_R$.

B. Pati-Salam Model

• Context: Based on the gauge group $SU(4) \otimes SU(2)_L \otimes SU(2)_R$.
• Findings:
  • Generated a $300 \times 300$$S$-matrix decomposing into 42 blocks.
  • Identified 23 distinct eigenvalues.
  • 10 eigenvalues were derived analytically; the remaining 13 required numerical computation.
  • Parameter Space: The bounds are slightly looser than MLRSM ($|\lambda_u| < 1$, $|\lambda_M| < 2.4$), implying $M \lesssim 2.2 v_R$.

C. Validation

The package was tested against a wide range of established models (SM + singlet, 2HDM, 3HDM, Georgi-Machacek, etc.), successfully reproducing known analytical results.

5. Significance

• Theoretical Rigor: Provides a robust, systematic method to ensure BSM models do not violate unitarity, a fundamental requirement for any viable quantum field theory.
• Accessibility: By releasing the anyPUB package (hosted on GitHub), the author lowers the barrier for researchers to perform these complex calculations without needing deep expertise in symbolic algebra or graph theory.
• Correcting the Record: The paper highlights that even published unitarity bounds can contain subtle algebraic errors, emphasizing the need for automated verification tools.
• Future Outlook: The tool is positioned to be a standard utility for the high-energy physics community, particularly for exploring the parameter spaces of complex multi-Higgs and grand unified theories.