group.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 GROUP_H_INCLUDED
#define GROUP_H_INCLUDED

#include <memory>
#include "semiSimpleAlgebra.h"
#include "SU_N_algebra.h"
#include "representation.h"
#include "mrtError.h"

// Forward declaration of QuantumFieldParent
namespace mty {
class QuantumFieldParent;
class GaugedGroup;
}

namespace mty {

namespace group {
enum class Type {

    Trivial, 
    O,       
    SO,      
    U1,      
    SU,      
    Sp,      
    E6,      
    E7,      
    E8,      
    F4,      
    G2,      
    Lorentz  
};

std::ostream& operator<<(std::ostream&    fout,
                         mty::group::Type type);

} // End of namespace group
} // End of namespace mty

namespace mty {

typedef class AbstractGroup {

    public:

    explicit
    AbstractGroup(const std::string& t_name = "");

    explicit
    AbstractGroup(int t_dim, const std::string& t_name = "");

    virtual
    ~AbstractGroup(){}

    virtual 
    SemiSimpleAlgebra* getAlgebra() const;

    virtual
    Irrep highestWeightRep(const std::vector<int>& highestWeight) const;

    virtual
    Irrep getTrivialRep() const = 0;

    virtual
    Irrep getAdjointRep() const;

    virtual
    group::Type getType() const = 0;

    mty::GaugedGroup *getGaugedGroup() const {
        return gauged;
    }
    void setGaugedGroup(mty::GaugedGroup *t_gauged) {
        gauged = t_gauged;
    }

    std::string getName() const;

    int getDim() const;

    virtual
    const csl::Space* getVectorSpace(const Irrep& irrep) const = 0;

    virtual
    AlgebraState getHighestWeight(const csl::Space* t_space) const;

    virtual
    std::vector<const csl::Space*> getAllVectorSpace() const = 0;

    virtual
    csl::Index getCorrespondingIndex(const std::string&        index_name, 
                                    const QuantumFieldParent& parent) = 0;

    protected:

    int dim;

    std::string name;

    mty::GaugedGroup *gauged;

} Group;


class SemiSimpleGroup: public AbstractGroup {

    public:

    explicit
    SemiSimpleGroup(const std::string& name);

    SemiSimpleGroup(const SemiSimpleAlgebra& t_algebra,
                    const std::string&       t_name);

    ~SemiSimpleGroup() override;

    SemiSimpleAlgebra* getAlgebra() const override;

    void setAlgebra(const SemiSimpleAlgebra& t_algebra);

    Irrep highestWeightRep(
            const std::vector<int>& highestWeight) const override;

    csl::Expr getQuadraticCasimir(const AlgebraState& highest) const;

    Irrep getTrivialRep() const override;

    SumIrrep tensorProduct(const Irrep& rep1,
                           const Irrep& rep2) const;

    SumIrrep tensorProduct(const std::initializer_list<int>& rep1,
                           const std::initializer_list<int>& rep2) const;

    const csl::Space* getVectorSpace(const Irrep& irrep) const override;

    AlgebraState getHighestWeight(const csl::Space* t_space) const override;

    std::vector<const csl::Space*> getAllVectorSpace() const override;

    csl::Index getCorrespondingIndex(
            const std::string&        index_name,
            const QuantumFieldParent& parent) override;

    protected:

    std::unique_ptr<SemiSimpleAlgebra> algebra;

    mutable
    std::vector<std::pair<AlgebraState, const csl::Space*>> vectorSpaces;

    mutable
    std::map<AlgebraState, csl::Expr>        quadraticCasimir;
};

} // End of namespace mty

namespace mty::group {

class U1: public mty::SemiSimpleGroup {

    public:

    explicit
    U1(std::string const& t_name = "");

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class SU: public mty::SemiSimpleGroup {

    public:

    explicit
    SU(std::string const& t_name,
       int                t_dim = 2);

    explicit
    SU(int t_dim = 2);

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class SO: public mty::SemiSimpleGroup {

    public:

    explicit
    SO(std::string const& t_name,
       int                t_dim = 3);

    explicit
    SO(int t_dim = 3);

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class Sp: public mty::SemiSimpleGroup {

    public:

    explicit
    Sp(std::string const& t_name,
       int                t_dim = 2);

    explicit
    Sp(int t_dim = 2);

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class E6: public mty::SemiSimpleGroup {

    public:

    explicit
    E6(std::string const& t_name = "");

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class E7: public mty::SemiSimpleGroup {

    public:

    explicit
    E7(std::string const& t_name = "");

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class E8: public mty::SemiSimpleGroup {

    public:

    explicit
    E8(std::string const& t_name = "");

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class F4: public mty::SemiSimpleGroup {

    public:

    explicit
    F4(std::string const& t_name = "");

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class G2: public mty::SemiSimpleGroup {

    public:

    explicit
    G2(std::string const& t_name = "");

    mty::group::Type getType() const override;

    mty::Irrep getAdjointRep() const override;
};

class Lorentz: public mty::SemiSimpleGroup {

    public:

    Lorentz();

    ~Lorentz(){}

    mty::group::Type getType() const override;
};

} // End of namespace mty::group

namespace mty {

std::unique_ptr<mty::SemiSimpleGroup> createGroup(
        group::Type       type,
        std::string const& name,
        int                dim = -1);

std::unique_ptr<mty::SemiSimpleGroup> createGroup(
        group::Type type,
        int          dim = -1);

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

group::Type stringToGroupType(std::string const& name);

inline mty::group::Lorentz *Lorentz = new mty::group::Lorentz();

} // End of namespace mty

#endif