PaperlayerView exact revision on arXiv

Source-linked AI summary

FeynRules - Feynman rules made easy

Neil D. Christensen, Claude Duhr

arXiv:0806.4194v1hep-ph

TL;DR

Implementing particle-physics models across different Feynman-diagram calculators is laborious because each program uses its own format. FeynRules derives Feynman rules from a Mathematica model file and translates the resulting generic model into supported calculators, with Standard Model vertices matching literature and implementations across validated processes.

  • Problem

    Different Feynman-diagram calculators require separate model implementations, while deriving rules and implementing new models involves extensive computational work.

  • Method

    FeynRules takes a Mathematica model file and Lagrangian, derives interaction vertices, stores them generically, and translates them into supported calculator formats.

  • Results

    The complete Standard Model implementation agreed with literature and matched existing calculator results across 22 selected processes and 189 key processes.

  • Takeaways & Limitations

    A single FeynRules model implementation can be automatically used with multiple calculators through translation interfaces.

  • Takeaways & Limitations

    Translation interfaces support only vertices, particles, parameters, and names allowed by their target calculators.

Abstract

from arXiv · show

In this paper we present FeynRules, a new Mathematica package that facilitates the implementation of new particle physics models. After the user implements the basic model information (e.g. particle content, parameters and Lagrangian), FeynRules derives the Feynman rules and stores them in a generic form suitable for translation to any Feynman diagram calculation program. The model can then be translated to the format specific to a particular Feynman diagram calculator via FeynRules translation interfaces. Such interfaces have been written for CalcHEP/CompHEP, FeynArts/FormCalc, MadGraph/MadEvent and Sherpa, making it possible to write a new model once and have it work in all of these programs. In this paper, we describe how to implement a new model, generate the Feynman rules, use a generic translation interface, and write a new translation interface. We also discuss the details of the FeynRules code.

PROGRAM SUMMARY … Index Definitions

FeynRules automates Feynman-rule derivation from Lagrangians and translates generic model implementations into multiple diagram and Monte Carlo programs. Its model-file structure supports fields, parameters, Lagrangians, metadata, and explicitly declared indices.

  • PROGRAM SUMMARY: FeynRules automatically derives Feynman rules from a Lagrangian and implements new models into FeynArts and Monte Carlo event generators.Its two-step method derives rules using canonical commutation relations, then translates models through interfaces.
  • PROGRAM SUMMARY: The package supports fields with spins 0, 1/2, 1, and 2, subject to basic quantum-field-theory requirements including Lorentz and gauge invariance.Running time ranges from seconds for the Standard Model to minutes for more complicated models such as the 3-Site Model.
  • 1 Introduction: FeynRules addresses collider phenomenology requiring automated computation of thousands or tens of thousands of Feynman diagrams for comparing new-physics models with experiment.The paper motivates the package through the LHC’s probing of the scale where the Higgs-less Standard Model violates unitarity.
  • 1 Introduction: FeynRules takes a Mathematica model file containing particles, parameters, and a Lagrangian, then derives interaction vertices using canonical quantization formalism.The algorithm also applies to effective theories containing higher-dimensional operators.
  • 1 Introduction: Its generic model format is independent of any particular diagram calculator, enabling translation interfaces and avoiding repeated, time-consuming, error-prone model implementations.Interfaces exist for CalcHEP/CompHEP, FeynArts/FormCalc, MadGraph/MadEvent, and Sherpa.
  • 2 The Model-File: A Feynman-diagram model comprises quantum fields, parameters, and a Lagrangian, which FeynRules stores in a generic format for translation to a chosen program.The model format extends FeynArts with additional classes and options useful for deriving rules and translating amplitudes.
  • Model Information: Model metadata can include a model name and an author signature listing names, institutions, emails, creation date, and references displayed when the model loads.The relevant variables are M$ModelName and M$Information.
  • Index Definitions: Indices are represented as Index[name, value] objects and must be declared with their ranges using IndexRange; Lorentz and Dirac indices are predefined.IndexStyle controls printed symbols, while NoUnfold can preserve an index declaration for FeynArts output.

Gauge Groups · Parameters

FeynRules models declare gauge-group classes and parameters through structured options in the model file. These declarations distinguish gauge-group properties and parameter dependencies or tensor structure, enabling consistent construction of interactions and calculations.

  • Gauge Groups: Gauge-group classes are named entries collected in M$GaugeGroups, with options specifying each group’s details.The complete option set is listed in Table 3.
  • Gauge Groups: Gauge groups are classified as abelian or non abelian through the Abelian option, set to True or False.This distinction determines the group’s interaction structure and related conventions.
  • Gauge Groups: Representations are declared as generator–index pairs, automatically defining generator tensors with an adjoint gauge-boson index and the acted-on indices.The relevant indices, including the adjoint index specified by GaugeBoson, must be declared.
  • Gauge Groups: Gauge-group declarations can specify gauge bosons, charges, coupling constants, structure constants, and representations for examples including U(1) and SU(3).For SU(3), T denotes the fundamental-representation matrices and Colour is the quark gauge index.
  • Gauge Groups: Declaring a gauge group automatically constructs its field-strength tensor for use in gauge-boson kinetic and self-interaction terms.Abelian tensors use FS[A, mu, nu], while the non abelian form includes the coupling, structure constant, and gauge boson; FR$DSign can change the convention from its default value 1 to -1.
  • Parameters: Parameters are user-defined model-file entries with optional information, including coupling constants, mixing angles, masses, and gauge charges.Parameters are listed using entries such as param1 == { options } and param2 == { options }.
  • Parameters: ParameterType distinguishes External independent parameters from Internal dependent parameters specified in terms of other quantities.For example, the strong coupling αs = 0.118 is external, while dependent relations must be encoded explicitly.
  • Parameters: Correct parameter relationships are crucial because violating the tree-level relation cos θW = MW/MZ in the Standard Model causes loss of unitarity and incorrect results.FeynRules also distinguishes scalar parameters without indices from tensor parameters carrying one or more indices; common and tensor-specific options are tabulated separately, and special names are required for built-in strong and electromagnetic interactions.

Scalar parameters · Tensor parameters

Scalar parameters use Value or Definitions to specify numerical values, formulas, and pre-vertex substitutions, while tensor parameters require component-wise assignments and support matrix constraints and index-handling options. Both parameter types also expose metadata and interface-specific options for generated model files and couplings.

  • Scalar parameters: Scalar parameters use Value for numbers or defining formulas, with internal-parameter formulas ordered after the parameters they reference.Value defaults to 1; external parameters take numerical values, while internal parameters take formulas involving internal or external parameters.
  • Scalar parameters: Definitions supplies replacement rules applied before vertex calculation, allowing parameters or tensor components to be substituted before deriving Feynman rules.For tensors, combining Definitions with Value can remove vertices whose specified components vanish, reducing the workload for FeynRules and downstream programs.
  • Scalar parameters: Scalar parameters are real by default, whereas ComplexParameter -> True marks them as complex.The corresponding option defaults to False for scalar parameters but to True for tensor parameters.
  • Scalar parameters: ParameterName, BlockName, OrderBlock, and InteractionOrder provide names, Les Houches placement, labels, and coupling-order information needed by interfaces and Monte Carlo programs.External parameters default to the FRBlock block and receive order-based labels; InteractionOrder has no default and is not inferred from parameter relations.
  • Tensor parameters: Tensor parameters are declared with Indices and require Value or Definitions assignments for each tensor component.A Cabibbo-matrix example assigns explicit CKM components through rules such as Sin[cabi] and Cos[cabi].
  • Tensor parameters: Tensors are internal and complex by default, and Unitary, Hermitian, or Orthogonal can declare corresponding matrix properties.Each of these structural options defaults to False.
  • Tensor parameters: AllowSummation -> True permits index structures that violate the usual paired-index summation convention, such as diagonal Yukawa matrices.This option is useful when writing yfH ¯ψfψf instead of an explicitly summed matrix expression.

Particle Classes

FeynRules organizes fields into spin-labeled particle classes whose members can share quantum numbers while differing in masses. Class declarations specify essential identity and conjugation information, along with indices, charges, flavor structure, basis transformations, masses, and interface metadata.

  • Spin-based classes: Particle classes are labeled by spin: S for scalars, F for Dirac or Majorana spinors, V for vectors, T for real spin-2 fields, and U for complex ghosts.This follows the original FeynArts syntax.
  • Class organization: A class can contain particles with identical quantum numbers but different masses, allowing compact Lagrangian expressions instead of separate terms for each flavor.The QCD example uses a quark class to avoid writing each quark-flavor term explicitly.
  • Mandatory options: Every particle class requires ClassName and SelfConjugate, which respectively define its Lagrangian symbol and whether it has an antiparticle.SelfConjugate accepts True or False, and FeynRules reads only classes with ClassName defined.
  • Field properties: Fields declare additional tensor indices with Indices, abelian charges with QuantumNumbers, and class members with ClassMembers; multi-member classes also require FlavorIndex for Lagrangian expansion.The declared index order matches the order used in the Lagrangian.
  • Basis and masses: Definitions transform gauge-basis fields into mass-basis fields before Feynman rules are derived, while Mass and Width specify class-member masses and decay rates.Mass entries may be symbolic or numerical, with Internal indicating a mass defined in the parameter list.
  • Calculator interfaces: Interface-specific options provide external names, suppress unphysical fields, assign PDG codes, and control propagator labels and line styles in diagram calculators.Existing PDG codes are strongly recommended when available.

3 The Lagrangian

FeynRules takes a model’s Lagrangian, entered in Mathematica form, and derives the corresponding Feynman rules. The section explains field and index notation, antiparticle handling, noncommuting products, and progressively explicit representations of interactions.

  • Lagrangian entry and rule derivation: FeynRules derives Feynman rules directly from the Lagrangian using particle and parameter information in the model file.The Lagrangian contains the model’s particle interactions, while deriving their mathematical Feynman-rule form can be tedious.
  • Lagrangian entry and rule derivation: The Lagrangian can be entered in a model file or Mathematica notebook using ordinary commands plus specialized notation for symbols such as Dirac matrices.A summary of the available commands is provided in Table 10.
  • Fields, indices, and antiparticles: Quantum fields use the form psi[a,b,c,...], with indices ordered as declared; implicit Lorentz or Spin indices appear first, while class members omit the flavor index.The same index notation applies to tensor parameters.
  • Fields, indices, and antiparticles: For non-self-conjugate fields, FeynRules creates antiparticle names by appending bar and also provides HC[e] and anti[e], with HC denoting hermitian conjugation.For example, ebar denotes the positron field when e denotes the electron field.
  • Noncommuting products: The Mathematica Dot command preserves anticommuting field order, whereas matrix products involving noncommuting entries must be wrapped with Inner[Dot,...] to avoid incorrect reordering.The nested Inner[Dot,...] construction yields the correct result.
  • Index suppression and QCD examples: FeynRules permits suppressed, partially explicit, or fully explicit indices in QCD interactions, allowing generations to remain generic, be separated by names, or be made entirely explicit.Explicit indices may be necessary to ensure correct contractions; named generations such as u, c, and t omit the generation index.

4 A Simple Example · Model Information · Indices

The section demonstrates a complete QCD model implementation in FeynRules, using it to explain model-file construction. It also specifies optional model metadata and the index declarations required for QCD fields.

  • 4 A Simple Example: The QCD implementation is complete, presenting every line of the model file while illustrating how to write a new model.The example does not use all FeynRules features; advanced examples are available in already implemented models.
  • 4 A Simple Example: The example introduces the QCD Lagrangian as the basis for constructing the model file.The section explicitly presents the Lagrangian considered before describing its field content.
  • 4 A Simple Example: The QCD field content includes the gluon field strength tensor, the gluon ghost field, and six quark flavors.The quark flavors are u, d, s, c, b, and t.
  • Model Information: Model information acts as an electronic signature and may document file modifications and convention-setting references.This frontmatter is optional but especially useful when the model user differs from its author.
  • Model Information: The example model metadata records the authors as N. Christensen and C. Duhr and identifies their institution.The supplied passage shows the metadata declaration beginning with Authors and Institutions.
  • Indices: Each model file must declare index types used in the model, except Lorentz and spin indices, which FeynRules hard codes.QCD uses color, gluon-adjoint-color, and flavor indices requiring declarations.
  • Indices: QCD assigns ranges 1–3 to fundamental color, 1–8 to adjoint gluon color, and 1–6 to flavor indices.Gluons also carry Lorentz indices from 1 to 4, while quarks carry spin indices from 1 to 4; ghost fields carry adjoint color.

Gauge Groups · Particles · Lagrangian

The model file defines the SU(3)c gauge group, QCD parameters, quark, gluon, and ghost particle classes, and the corresponding QCD Lagrangian. These ingredients enable FeynRules to derive the interaction vertices and support translation to Monte Carlo programs.

  • Gauge Groups: FeynRules defines the QCD gauge group SU(3)c with gluon, structure-constant, representation, and strong-coupling assignments.The gauge-group class uses G, f, {T, Colour}, and gs for the corresponding properties.
  • Gauge Groups: Gauge-group conventions are chosen to match those used by Monte Carlo programs with hard-coded strong interactions.These conventions are not required for deriving correct Feynman rules but matter for translation interfaces.
  • Gauge Groups: The strong coupling is implemented through external αs = 0.118 and internal gs = Sqrt[4 Pi αs] parameters.The external parameter uses ParameterName aS and the internal parameter uses ParameterName G for Monte Carlo model files.
  • Particles: The particle definitions comprise quarks d, u, s, c, b, t, self-conjugate gluons, and gluon-associated ghosts.The quark class carries flavor and colour indices, while the gluon and ghost classes use gluon indices.
  • Particles: Quark masses and widths are specified member by member, with masses {MC, 1.25}, {MB, 4.5}, {MT, 174} and top width WT = 1.6.The class also includes a generic mass symbol MQ and PDG codes 1 through 6.
  • Lagrangian: The Lagrangian includes QCD quark–gluon interactions, generic quark mass terms MQ[f], and a ghost term built from the gluon’s BRST transformation.Users may define Mathematica routines to simplify the Lagrangian and may place it in the model file or notebook.
  • Lagrangian: With the gauge, parameter, particle, and Lagrangian classes defined, FeynRules can derive the associated interaction vertices.The resulting vertices are introduced as the next stage of the workflow.

5 Running FeynRules … Extracting the Feynman Rules

FeynRules loads a model and Lagrangian, extracts the corresponding Feynman rules, and stores them as an internally structured vertex list. Users can control screen output, flavor expansion, vertex selection, conservation checks, and the assembly of rules from separate Lagrangian pieces.

  • 5 Running FeynRules: After creating the model file and Lagrangian, users load them into FeynRules to obtain the Feynman rules.The package must first be located and loaded in Mathematica.
  • Loading the Model-File: After FeynRules is loaded, LoadModel imports one or multiple .fr model files.A model may be split across several files, but each file must use the .fr extension.
  • Extracting the Feynman Rules: FeynmanRules extracts vertices from the loaded model and Lagrangian, displaying them and storing them internally in a vertex variable.The QCD Lagrangian provides the section’s example application.
  • Extracting the Feynman Rules: The ScreenOutput option generates and stores the rules in vertsQCD without displaying them on screen.This is useful when the vertex list is long.
  • Extracting the Feynman Rules: FlavorExpand produces separate vertices for individual flavors instead of leaving flavor indices unexpanded.For example, one generic quark-gluon vertex can become distinct d dbar G, u ubar G, and s sbar G vertices.
  • Extracting the Feynman Rules: Vertex construction can be restricted by external-leg count, canonical dimension, or explicitly selected particle combinations.FeynmanRules also checks quantum-number conservation by default, with ConservedQuantumNumbers controlling that behavior.
  • Extracting the Feynman Rules: Each internally stored vertex pairs its participating particles with the analytical vertex expression, while each particle records its name and associated index label.SelectVertices can further filter an already derived list using shared selection options.
  • Extracting the Feynman Rules: Rules derived separately for different Lagrangian pieces can be combined with MergeVertices, which merges identical contributions into one vertex.The QCD example constructs gluon, quark, and ghost rules separately before merging them into vertsQCD.

Writing TEX Output … Checking a Lagrangian

FeynRules’ ToolBox supports model documentation, parameter-file manipulation, Lagrangian decomposition and mass-spectrum extraction, while providing checks for key consistency conditions. These utilities complement Feynman-rule derivation by helping users inspect, implement and validate models in Mathematica.

  • Writing TEX Output: WriteTeXOutput generates a TEX file containing selected vertices and optionally the Lagrangian, with configurable output naming.The command takes a list of desired vertices; the default filename is M$ModelName.tex, and PrintLagrangian -> True includes the Lagrangian.
  • Manipulating Parameters: NumericalValue evaluates numerical parameter expressions, while UpdateParameters changes selected external parameters such as gs and ee.Examples include NumericalValue[ Sin[ cabi ]] and UpdateParameters[ gs -> 0.118 , ee -> 0.33 ].
  • Manipulating Parameters: WriteParameters and ReadParameters exchange parameter data through configurable files, but ReadParameters imports only external parameters and changes to internal parameters are ignored.WriteParameters includes external and internal parameters, including masses and widths; ReadParameters reads external parameters, including external masses and widths.
  • 6 The ToolBox: The FeynRules ToolBox provides auxiliary functions for manipulating vertex lists, checking Lagrangian properties and supporting model implementation.Its boolean functions identify symbols corresponding to particles, parameters and other model objects for pattern matching in user-written routines.
  • Manipulating a Lagrangian: ExpandIndices restores suppressed indices and can expand a Lagrangian over flavor indices using FlavorExpand -> True.ExpandIndices shares FeynmanRules options, and ExpandIndices[ L , FlavorExpand -> True] returns L expanded over all flavor indices.
  • Manipulating a Lagrangian: Lagrangian-filtering functions extract kinetic, mass, quadratic or interaction terms, while SelectFieldContent isolates specified field combinations.GetKineticTerms returns quadratic terms with derivatives; analogous functions provide other sectors, and SelectFieldContent can select three- and four-point gluon vertices.
  • Manipulating a Lagrangian: GetMassSpectrum calculates numeric or symbolic masses from the Lagrangian, provided the Lagrangian is already in mass diagonal form.FeynRules does not currently diagonalize mass matrices, so this feature requires diagonal mass terms.
  • Checking a Lagrangian: Lagrangian checks test hermiticity, diagonal quadratic structures, kinetic-term normalization and agreement between model-file and Lagrangian mass spectra.CheckHermiticity evaluates the Feynman rules of L − L†, while the diagonalization, normalization and mass-spectrum checks require the relevant terms to be diagonal.

Manipulating vertex lists · 7 Interfaces · Special Names

FeynRules provides momentum-conservation tools for simplifying vertex lists, interfaces for translating models into several Feynman-diagram calculators, and naming conventions that improve translation compatibility. These interfaces impose calculator-specific constraints, while special particle and parameter names support standardized model implementation.

  • Manipulating vertex lists: MomentumReplace replaces one particle momentum by minus the sum of all other momenta in a single vertex.It operates on an individual element of a vertex list.
  • Manipulating vertex lists: ApplyMomentumConservation simplifies every vertex by testing momentum substitutions and retaining the shortest resulting expression.It cycles through each momentum using MomentumReplace.
  • 7 Interfaces: Four translation interfaces support CalcHEP/CompHEP, FeynArts/FormCalc, MadGraph/MadEvent, and Sherpa.They allow one implemented model to be translated into multiple calculator-specific formats.
  • 7 Interfaces: Commands such as WriteCHOutput, WriteFeynArtsOutput, WriteMGOutput, and WriteSHOutput invoke interfaces for selected Lagrangian terms and interface-specific options.The general command form is Write__Output[l1,l2,..., options].
  • 7 Interfaces: Interfaces support only vertices, particles, parameters, and names allowed by their target calculators, warning users about unsupported terms.In some cases, an interface may fix an unsupported term automatically and warn the user.
  • 7 Interfaces: Calculator gauge choices can require different particle sets and Lagrangian terms, so model files can use switches such as FeynmanGauge in if...else statements.The passage distinguishes Feynman-gauge and unitary-gauge calculators.
  • Special Names: FeynRules fixes names for special calculator objects, including strong-sector names G, gs, f, dSU3, T, Colour, and Gluon.The conventions cover the QCD gauge boson, coupling, structure constants, symmetric tensor, representations, and representation indices.
  • Special Names: Standard electromagnetic and electroweak names include ee and Q, while Fermi constant and Z pole mass inputs belong in SMINPUTS; masses, widths, and PDG codes should also be assigned when possible.The strong coupling uses external αS and internal gS definitions, with coupling values set at the Z pole or interaction scale depending on whether the calculator runs them.

8 Implementing an Interface · The Particle List

FeynRules stores model information generically so interfaces can translate it into formats for different Feynman diagram calculators. The model is organized primarily through five lists, with PartList encoding particle classes and their properties for interface generation.

  • 8 Implementing an Interface: FeynRules stores model information generically, enabling translation into model files for different Feynman diagram calculators through interfaces.The paper includes existing interfaces and a template to support writing additional interfaces.
  • 8 Implementing an Interface: The model information is primarily stored in PartList, MassList, WidthList, EParamList and IParamList.Interfaces use these lists to generate files in the format required by a particular diagram calculator.
  • The Particle List: PartList contains all model particles, with each element describing one particle class and its properties.The charged +2/3 quark example contains class members for the u, c and t quarks.
  • The Particle List: Each PartList class begins with a class type and number, followed by a list of class members and their properties.The example identifies the class as fermionic with class number 3 and includes three charged +2/3 quark members.
  • The Particle List: In the quark example, the u-quark is massless, while the c-quark and t-quark use mass symbols MC and MT.The corresponding width element is also stored for each particle member.
  • The Particle List: PartList also stores full names, TEX names for particles and antiparticles, and the gauge boson associated with a Goldstone boson.The quark entries use FullName values such as "u-quark" and NoGS because the quarks are not Goldstone bosons.

The Mass and Width Lists … Model File Format

FeynRules organizes model data into structured particle, mass, width, external-parameter, and internal-parameter lists, then uses translation interfaces to convert these data and derived vertices into calculator-specific files. Its model format extends FeynArts with classes and adds parameter and gauge-group definitions while deriving vertices from the Lagrangian.

  • The Mass and Width Lists: MassList and WidthList are two-component lists containing the labels “Mass” or “Width” and particle masses or widths.For the top quark, the entries identify PDG number 6, symbols MT and WT, and values 174.3 and 1.50834.
  • The Internal Parameter List: IParamList records each internal parameter’s name, defining formula, interaction order, complexity flag, and description.The example defines aEW as aEWM1^(-1), second order in QED, real, and the electroweak coupling constant.
  • Writing a Translation Interface: A translation interface cycles through model lists and writes their contents into the format required by a particular Feynman diagram calculator.The suggested interface includes functions for overall output, particles, external and internal parameters, and vertices.
  • Writing a Translation Interface: Interface writers commonly use ParamRules and PartName to map Mathematica parameter and particle symbols to calculator-compatible names.A TemplateInterface.m file provides a starting point that can be copied or modified for a new format.
  • Model File Format: The FeynRules model file format extends FeynArts by grouping particles into classes in M$ClassesDeclaration, enabling compact definitions and additional properties such as PDG numbers.Classes also support particle properties needed when translating to calculators beyond FeynArts.
  • Model File Format: FeynRules removes M$CouplingMatrices because vertices come from the Lagrangian, while adding M$Parameters and M$GaugeGroups for model definitions absent from FeynArts.Class-based lists are read during initialization, and the resulting lists together with Feynman rules suffice to write calculator model files.

Index Restoration · Feynman Rules

FeynRules restores and contracts indices according to model-defined ordering before deriving Feynman rules through canonical quantization. The procedure handles tensor products, field contractions, derivatives, creation operators, and final vertex construction.

  • Index Restoration: FeynRules first restores all indices according to the ordering defined in the model file, then contracts same-type indices between nearest neighbors.Contraction begins with nonfield terms such as parameters and gamma matrices.
  • Index Restoration: In the quark–W-boson example, gamma matrices, projectors, and the CKM matrix receive indices according to their definitions before contraction.The CKM matrix carries generation indices, while gamma matrices and projectors carry spin and Lorentz indices.
  • Index Restoration: Matrix tensors use their final two indices as matrix indices, and FeynRules contracts nearest neighbors while attaching endpoint indices to the corresponding fields.Different index types prevent ambiguity in the contractions.
  • Index Restoration: After contraction, matrix elements can be treated as numbers outside the Dot chain, while matrix products are wrapped in TensDot to avoid interconnected indices.Remaining field indices that do not connect to tensors are contracted pairwise.
  • Feynman Rules: Feynman rules are generated by multiplying a Lagrangian term by field creation operators with all momenta taken ingoing, reversing fermion and ghost operator order.The resulting operator product is evaluated between vacuum states using canonical quantization.
  • Feynman Rules: Creation operators are moved left using the (anti)commutation rules until they annihilate the vacuum, after which the vacuum states contribute one.This is the intermediate operator-reordering step in the canonical derivation.
  • Feynman Rules: Derivatives produce momentum factors; dropping the exponential and wavefunctions and multiplying by i yields the Feynman-rule vertex.The procedure is illustrated for the QED interaction and recovers the well-known QED vertex.

Majorana Fermions and Conjugated Fermions · Implemented models and validation · 10 Conclusions

FeynRules handles Majorana fermions and explicit charge conjugation through consistent fermion-flow transformations, and its model implementations were validated against literature, existing programs, and Monte Carlo results. The paper concludes that the package automates extracting interaction vertices and translating new physics models into several calculation tools.

  • Majorana Fermions and Conjugated Fermions: FeynRules applies a fermion-flow algorithm to interactions involving Majorana fermions and explicit charge conjugation.Charge-conjugation terms are handled through analogous transformations.
  • Majorana Fermions and Conjugated Fermions: For identical Majorana fermions, FeynRules accounts for self-conjugacy and symmetrizes the reversed fermion flow.The reversed chain uses κ_i = ±1 and reverses the Dirac-matrix ordering.
  • Majorana Fermions and Conjugated Fermions: For distinct Majorana fermions, FeynRules avoids symmetrization but uses the same fermion flow for all vertex contributions.This preserves a consistent ordering for the fermion chain.
  • Majorana Fermions and Conjugated Fermions: The convention treats ψ2 as ingoing and ψ1 as outgoing for vertices of the form (X, ψ̄1, ψ2), while Majorana bars indicate flow direction rather than antiparticles.The two flows for vertices containing two Majorana fermions are represented separately.
  • Implemented models and validation: FeynRules validation compared derived vertices with literature and checked Monte Carlo cross sections against stock program versions.The implemented models were also tested through the corresponding FeynRules interfaces.
  • Implemented models and validation: The complete Standard Model showed complete agreement with literature vertices in both unitary and Feynman gauges, and its FeynArts couplings matched the default model file.The Standard Model implementation was also compared with Monte Carlo results.
  • Implemented models and validation: The Three-Site Model was checked against an existing CalcHEP implementation on 189 key processes in both gauges and in CalcHEP and CompHEP.MadGraph/MadEvent supports only unitary gauge.
  • Implemented models and validation: MSSM and minimal-extra-dimension implementations matched known textbook vertices, while their Monte Carlo and FeynArts/FormCalc validation was still ongoing.The implemented models are downloadable as base models for extensions or new model files.
Loading 0806.4194v1…