quantumField.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// MARTY is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef QUANTUMFIELD_H
#define QUANTUMFIELD_H

#include <typeinfo>
#include "mrtError.h"
#include "gauge.h"
#include "flavor.h"
#include "iterable.h"
#include "quantumNumber.h"
#include "latexLink.h"
#include "doc_brown_link.h"


namespace mty {
enum class Chirality {
    Left = 0,  
    Right = 1, 
    None = 2   
};

Chirality operator!(Chirality init);

inline
std::ostream &operator<<(std::ostream &out, Chirality chir)
{
    switch(chir) {
        case Chirality::Left: out << "Left"; break;
        case Chirality::Right: out << "Right"; break;
        default: out << "No chirality";
    }
    return out;
}

    class Particle;
    class QuantumField;
    class WeylFermion;
    class DiracFermion;
    class GaugeBoson;
    class GhostBoson;
    class GoldstoneBoson;

inline csl::Tensor defaultSpaceTimePoint = csl::tensor_s(
        "X",
        &csl::Minkowski
        );

enum class ParticleType {

    ScalarBoson,
    VectorBoson,
    FieldStrength,
    GhostBoson,
    GoldstoneBoson,
    WeylFermion,
    DiracFermion,
};

std::ostream &operator<<(
        std::ostream &out,
        ParticleType  type
        );

struct PartnerShip {
    int self    { -1    };
    int partner { -1    };
    bool isLeft { false };

    bool isHappyWith(PartnerShip const &other) const {
        // Sufficient condition
        return self != -1 && self == other.partner;
    }
};

class QuantumFieldParent: public csl::TensorFieldParent {

    public:

    using Propagator_func = std::function<
        csl::Expr(QuantumField const&,
             QuantumField const&,
             csl::Tensor &,
             bool)>;

    protected:

    bool bosonic;

    bool selfConjugate = false;

    bool integratedOut = false;

    bool physical = true;

    bool enabledInDiagrams = true;

    csl::Expr mass = CSL_0;

    csl::Expr width = CSL_0;

    drawer::ParticleType drawType = drawer::ParticleType::None;

    Group* stGroup;
    
    Irrep spin;

    Gauge* gauge;

    GaugeIrrep irrep;

    bool polarizationSumInitialized = false;

    size_t firstGaugeIndex;

    size_t firstSpaceIndex;

    const Flavor* flavor;

    FlavorIrrep flavorRep;

    mutable
    std::map<QuantumNumber::ID, QuantumNumber::Value> qNumbers;

    std::map<QuantumFieldParent const*, Propagator_func> propagator;

    std::vector<std::weak_ptr<mty::QuantumFieldParent>> relatives;

    public:

    QuantumFieldParent() = default;

    QuantumFieldParent(QuantumFieldParent const& other) = default;

    QuantumFieldParent(const std::string& t_name,
                       int                t_spin,
                       Gauge*             t_gauge);

    QuantumFieldParent(const std::string& t_name,
                       int                t_spin,
                       const GaugeIrrep&  irrep);

    QuantumFieldParent(const std::string& t_name,
                       int                t_spin,
                       Gauge*             t_gauge,
                       bool               t_isSelfConjugate);

    QuantumFieldParent(const std::string& t_name,
                       int                t_spin,
                       const GaugeIrrep&  irrep,
                       bool               t_isSelfConjugate);

    QuantumFieldParent(const std::string& t_name,
                       int                t_spin,
                       const GaugeIrrep&  irrep,
                       const FlavorIrrep& flavorRep);

    QuantumFieldParent(const std::string&        t_name,
                       const QuantumFieldParent* other);

    drawer::ParticleType getDrawType() const;

    virtual bool contains(QuantumFieldParent const *other) const {
        return this == other;
    }

    virtual bool isSameSpecies(QuantumFieldParent const *other) const {
        return this == other;
    }

    virtual ParticleType getParticleType() const;

    void setDrawType(drawer::ParticleType type);

    virtual Particle generateSimilar(std::string const& t_name) const = 0;

    virtual Chirality getChirality() const;

    virtual csl::Expr getEnergyDimension() const = 0;

    virtual int getNDegreesOfFreedom() const = 0;

    int getNGaugeDegreesOfFreedom() const;

    virtual bool hasSpecialContractionWith(QuantumField const& other) const;

    virtual bool isChiral() const;

    virtual Particle getChiralityCounterPart() const;

    virtual Particle getWeylFermion(Chirality chirality) const;

    virtual Particle getDiracParent() const;

    virtual Particle getGoldstone() const;

    virtual void setDiracParent(Particle const &diracFermion);

    virtual csl::Expr getPropagator(QuantumField const& self,
                               QuantumField const& other,
                               csl::Tensor      & P,
                               bool                external) const;

    virtual csl::Expr getInvPropagator(QuantumField const& other,
                                  QuantumField const& self,
                                  csl::Tensor      & P,
                                  bool                external) const;

    virtual csl::Expr getKineticTerm(csl::Tensor & X);

    virtual bool isGaugeBoson() const;

    virtual csl::Expr getXiGauge() const;

    virtual Particle getVectorBoson() const;

    virtual GaugedGroup const* getGaugedGroup() const;
    virtual GaugedGroup* getGaugedGroup();

    virtual Particle getGoldstoneBoson() const;

    virtual Particle getGhostBoson() const;

    virtual Particle getConjugatedGhostBoson() const;

    virtual void setGoldstoneBoson(Particle const& goldstone);

    virtual void setGhostBoson(Particle const& ghost);

    virtual void setConjugatedGhostBoson(Particle const& ghost);

    virtual bool hasFieldStrength() const;

    virtual Particle getFieldStrength() const;

    virtual void setFieldStrength(Particle const& fieldStrength);

    bool isContractibleWith(QuantumFieldParent const* other) const;

    bool isBosonic() const;

    bool isFermionic() const;

    virtual bool isAntiCommuting() const;

    bool isSelfConjugate() const;

    bool isReal() const;

    bool isPhysical() const;

    bool isEnabledInDiagrams() const;

    bool isIntegratedOut() const;

    int getSpinDimension() const;

    csl::Expr getMass() const;

    csl::Expr getSquaredMass() const;

    csl::Expr getWidth() const;

    virtual mty::gauge::Choice getGaugeChoice() const;

    Irrep getLorentzRep() const;

    Gauge* getGauge() const;
    
    GaugeIrrep getGaugeIrrep() const;

    Irrep getGroupIrrep(const Group* group) const;

    Flavor const* getFlavor() const;

    void setFlavor(Flavor const *flavor);
    FlavorIrrep getFlavorIrrep() const;

    Irrep getFlavorIrrep(const FlavorGroup* group) const;

    std::vector<csl::Index> getSpaceIndex(
            const std::string& nameIndex = "") const;

    std::vector<csl::Index> getGaugeIndex(std::vector<std::string> names
            = std::vector<std::string>()) const;

    std::vector<csl::Index> getFlavorIndex(std::vector<std::string> names
            = std::vector<std::string>()) const;

    std::vector<csl::Index> getFullSetOfIndices() const;

    QuantumNumber::Value getQuantumNumber(
            QuantumNumber const* number) const;

    QuantumNumber::Value getQuantumNumber(
            QuantumField  const* instance,
            QuantumNumber const* number) const;

    csl::Expr getInstance(csl::Tensor point = defaultSpaceTimePoint);

    void integrateOut(bool value = true);

    void setMass(const std::string& t_mass);

    void setMass(const std::string& t_mass, long double value);

    void setMass(const csl::Expr& t_mass);

    void setWidth(const csl::Expr& t_width);

    virtual void setGaugeChoice(gauge::Type type);

    void setSelfConjugate(bool t_selfConjugate);

    void setPhysical(bool t_physical);

    void setEnabledInDiagrams(bool t_enabled);

    void adjustFlavorRep(Flavor* t_flavor);

    void setGaugeIrrep(const GaugeIrrep& newRep);
    void setGroupRep(Group*       group, 
                     const Irrep& newRep);

    void setGroupRep(std::string      const& group,
                     std::vector<int> const& highestWeight);

    void setGroupRep(std::string const& group,
                     int                charge);

    void setFlavorRep(const FlavorGroup* group, 
                      const Irrep&       newRep);
    void setFundamentalFlavorRep(
            std::string const &flavorGroup
            );

    void addQuantumNumber(QuantumNumber const& number,
                          QuantumNumber::Value value);

    virtual void setBrokenParts(
            const csl::Space*            broken,
            const std::vector<Particle>& brokenParts);

    std::vector<csl::Parent> breakSpace(
            const csl::Space*                     broken,
            const std::vector<const csl::Space*>& newSpace,
            const std::vector<size_t>&           pieces
            ) const override;

    QuantumFieldParent& operator=(const QuantumFieldParent& other) = default;

    friend
    std::ostream& operator<<(std::ostream& fout, const QuantumFieldParent& obj);

    csl::Expr operator()(const csl::Tensor& t_point) override;

    csl::Expr operator()(csl::Index          index,
                    const csl::Tensor& t_point) override;

    csl::Expr operator()(std::vector<int> const& indices,
                    const csl::Tensor&     t_point) override;

    csl::Expr operator()(std::vector<csl::Index> indices,
                    const csl::Tensor&     t_point) override;

    csl::Expr operator()(csl::Index              polarization,
                    std::vector<int> const& indices,
                    const csl::Tensor&     t_point);

    csl::Expr operator()();

    csl::Expr operator()(csl::Index index) override;

    csl::Expr operator()(std::vector<csl::Index> indices) override;

    csl::Expr operator()(csl::Index          polarization,
                    csl::Index          index,
                    const csl::Tensor& momentum);

    csl::Expr operator()(csl::Index              polarization,
                    std::vector<csl::Index> indices,
                    const csl::Tensor&     momentum);

    operator csl::Expr();

    virtual void breakParticle(
            mty::Group                     *brokenGroup,
            std::vector<std::string> const &newNames
            );
    virtual void breakParticle(
            mty::FlavorGroup                     *brokenFlavor,
            std::vector<mty::FlavorGroup*> const &subGroups,
            std::vector<std::string>       const &names
            );

    protected:

    void addRelative(std::weak_ptr<mty::QuantumFieldParent> const &particle);

    std::weak_ptr<mty::QuantumFieldParent> removeRelative(
            QuantumFieldParent const *particle
            );

    void checkRelatives();

    template<class Func>
    void applyToRelatives(Func &&func);

    void printQuantumDefinition(
            std::ostream &out,
            int           indentSize
            ) const;

    virtual void initPropagator();

    void initIndexSpaces();

    void initPolarizationSum();

    void setPropagator(QuantumFieldParent const* other,
                       Propagator_func prop);

    friend
    void AddCustomPropagator(QuantumFieldParent* left,
                             QuantumFieldParent* right,
                             QuantumFieldParent::Propagator_func propagator);

    friend
    void AddCustomPropagator(QuantumFieldParent* field,
                             QuantumFieldParent::Propagator_func propagator);

};

class Particle: public std::shared_ptr<QuantumFieldParent> {

    public:

    INHERIT_SHARED_PTR_CONSTRUCTOR(Particle, mty::QuantumFieldParent)

    
    template<class ...Args>
        inline
        csl::Expr operator()(Args&& ...args)
        {
            return (**this)(std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const csl::Index& polar,
                        const csl::Index& index,\
                        Args&&               ...args)
        {
            return (**this)(polar, index, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const std::vector<int>& indices,\
                        Args&&                     ...args)
        {
            return (**this)(indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(std::initializer_list<int> indices,\
                        Args&&                     ...args)
        {
            return (**this)(indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const csl::Index&              polar,
                        const std::vector<int>& indices,\
                        Args&&                     ...args)
        {
            return (**this)(polar, indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const csl::Index&              polar,
                        const std::vector<csl::Index>& indices,\
                        Args&&                     ...args)
        {
            return (**this)(polar, indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const csl::Index&              polar,
                        std::initializer_list<int> indices,\
                        Args&&                     ...args)
        {
            return (**this)(polar, indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const csl::Index&              polar,
                        std::initializer_list<csl::Index> indices,\
                        Args&&                     ...args)
        {
            return (**this)(polar, indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(const std::vector<csl::Index>& indices,\
                        Args&&                     ...args)
        {
            return (**this)(indices, std::forward<Args>(args)...);
        }

    template<class ...Args>
        inline
        csl::Expr operator()(std::initializer_list<csl::Index> indices,\
                        Args&&                     ...args)
        {
            return (**this)(indices, std::forward<Args>(args)...);
        }

    operator csl::Expr() 
    {
        return csl::Expr(**this);
    }
};

class QuantumField: public csl::TensorFieldElement {

    protected:

    bool particle = true;

    bool external = false;

    bool onShell = false;

    bool incoming = true;

    csl::IndexStructure derivativeIndices {};

    PartnerShip partnerShip {};

    public:

    QuantumField(const csl::Tensor& t_vector,
                 const csl::Parent&  t_parent);

    QuantumField(const csl::Tensor& t_vector,
                 const csl::Parent&  t_parent,
                 const std::vector<csl::Index>& indices);

    QuantumField(const csl::Tensor& t_vector,
                 const csl::Parent&  t_parent,
                 const csl::IndexStructure& indices);

    public:

    template<typename ...Args>
    friend csl::Expr quantumfield_s(Args&& ...args);

    QuantumField();

    QuantumField(QuantumField const&) = default;

    QuantumField(QuantumField&&) = default;

    QuantumField& operator=(const QuantumField& other) = default;

    QuantumField& operator=(QuantumField&&) = default;

    inline
    QuantumFieldParent* getQuantumParent() const {
        return static_cast<QuantumFieldParent*>(parent.get());
    }

    inline 
    Particle getParticle() const {
        return std::static_pointer_cast<QuantumFieldParent>(parent);
    }

    auto getGaugeIrrep() const {
        auto rep = getQuantumParent()->getGaugeIrrep();
        return (conjugated) ? rep.getConjugatedRep() : rep;
    }
    auto getFlavorIrrep() const {
        auto rep = getQuantumParent()->getFlavorIrrep();
        return rep;
    }
    template<class GroupType>
    auto getGroupIrrep(GroupType &&group) const {
        auto rep = getQuantumParent()->getGroupIrrep(std::forward<GroupType>(group));
        return (conjugated) ? rep.getConjugatedRep() : rep;
    }
    template<class FlavorGroupType>
    auto getFlavorIrrep(FlavorGroupType &&group) const {
        auto rep = getQuantumParent()->getFlavorIrrep(std::forward<FlavorGroupType>(group));
        return rep;
    }

    int getSpinDimension() const;

    csl::Expr getEnergyDimension() const;

    csl::Expr getMass() const;

    csl::Expr getWidth() const;

    PartnerShip getPartnerShip() const {
        return partnerShip;
    }

    bool isChiral() const;

    Chirality getChirality() const;

    void setChirality(Chirality chirality);

    bool isGaugeBoson() const;

    csl::Expr getXiGauge() const;

    csl::Expr getSquaredMass() const;

    bool getConjugated() const;

    bool isExternal() const;

    bool isOnShell() const;

    bool isBosonic() const;

    bool isFermionic() const;

    bool isAntiCommuting() const;

    bool isSelfConjugate() const;

    bool isReal() const override;

    bool isPhysical() const;

    bool isContractibleWith(const QuantumField& other) const;

    bool isExactlyContractiblewith(const QuantumField& other) const;

    void addDerivative(const csl::Index& index);

    bool hasDerivative() const;

    csl::IndexStructure getDerivativeStructure() const;

    csl::Expr getPropagator(const QuantumField& other,
                       csl::Tensor&       vertex) const;

    csl::Expr getLSZInsertion(
            const csl::Tensor& momentum,
            bool               ruleMode = false,
            bool               lock = false
            ) const;

    QuantumField getConjugatedField() const;

    csl::Expr contraction(csl::Expr_info other) const override;

    virtual csl::Expr matrixChargeConjugation(csl::Expr_info other) const;

    std::optional<csl::Expr> getComplexConjugate() const override;

    void conjugate();

    void setExternal(bool t_external);

    void setOnShell(bool t_onShell);

    virtual void setIncoming(bool t_incoming);

    virtual void setParticle(bool t_particle);

    void setPartnerShip(PartnerShip const &t_partnerShip) {
        partnerShip = t_partnerShip;
    }

    void setDerivativeStructure(const csl::IndexStructure& structure);

    bool getCommutable() const override;

    bool commutesWith(csl::Expr_info other, int sign=-1) const override;

    bool hasContractionProperty(csl::Expr_info expr) const override;

    csl::unique_Expr copy_unique() const override;

    bool isIndexed() const override;

    bool operator==(csl::Expr_info other) const override;

    bool compareWithDummy(csl::Expr_info other,
                          std::map<csl::Index, csl::Index>& constraints,
                          bool keepAllCosntraints = false) const override;

    bool operator<(const QuantumField& other) const;

    bool operator==(const QuantumField& other) const;

    bool operator!=(const QuantumField& other) const;

    bool isParticle() const;

    bool isIncoming() const;

    bool isIncomingParticle() const;

    bool isOutgoingParticle() const;

    bool isIncomingAntiParticle() const;

    bool isOutgoingAntiParticle() const;
};

template<class Func>
void QuantumFieldParent::applyToRelatives(Func &&func) {
    checkRelatives();
    for (auto &rel : relatives) {
        // Making sure to avoid any loop dependency here
        auto shared = rel.lock();
        auto self = shared->removeRelative(this);
        func(mty::Particle(shared));
        if (self.lock())
            shared->addRelative(self);
    }
}

template<typename ...Args>
csl::Expr quantumfield_s(Args&& ...args)
{
    auto field = csl::make_shared<QuantumField>(std::forward<Args>(args)...);
    field->getCanonicalPermutation();
    return field;
}

csl::Expr getMomentumSum(const std::vector<QuantumField>&  insertions,
                     const std::vector<csl::Tensor>& impulsions,
                     const csl::Index&                index);

std::ostream& operator<<(std::ostream& fout,
                         const mty::QuantumField& field);


} // End of namespace mty

#endif /* QUANTUMFIELD_H */