AbstractFiniteGroup

Abstract type of finite groups. Group elements are labeled by integers. The identity element are 1 by default.

binary_search

burnside(g::FiniteGroup, h::AbstractArray{<:Integer, 3}; tol::Real=1e-7)

Get character table using Burnside's method.

charactertable(g::AbstractFiniteGroup; method)

Return the character table of group g. Use Burnside's method.

Check whether a multiplication table

Check whether a linear representation of the cover group of g is indeed the projective representation obeying the projective coefficients.

check_real_rep(g::AbstractFiniteGroup, χ)

Check whether a representation is real/complex/pseudo-real: +1 : Real 0 : Complex -1 : Pseudo-real

Check whether a group is legit

chiral_proj_reps(g, χ; R=true)

Representation of g with a chiral operator S, which is represented by Diagonal([1, …, 1, -1, …, -1]).

class_multab(multable, classes, class_vec)

Compute class multiplicity:

Cᵢ × Cⱼ = hᵢⱼₖ Cₖ

Outputs:

h::Array{Int64, 3} : Class multiplicity.

Given a vector specifying the classes each element is in, collect the elements in each class.

conjugate_class(multable::AbstractMatrix, ginv::Union{AbstractVector,Nothing}=nothing)

Compute the conjugate class.

Outputs:

classes : Vector of vector which contains the element in that class. class_vec : Vector indicating the class each group element is in.

cover_group(g::AbstractFiniteGroup, coeff::AbstractMatrix{<:Integer}, p::Integer)

Construct the cover group of g, given the projective coefficient coeff. The projective coefficient is unitary and the phase is module p.

Inputs:

g : Finite group. coeff : D(gᵢ) * D(gⱼ) = exp(i2π/p * coeff[i,j]) * D(gᵢ⋅gⱼ). p : Module of coefficient.

double_group(g::AbstractFiniteGroup, χ::AbstractVector{<:Integer})

Construct a double group with element g⊕S⋅g, satisfying: gᵢS⋅gⱼ = S⋅gᵢgⱼ, The projective coefficients is: D(gᵢ)D(S⋅gⱼ) = χᵢD(S⋅gᵢgⱼ)

The function takes Finitegroup g and coefficent χ, and return the doubled group together with the projective coefficients.

Return the transformation matrix between two equivalent irreducible representation rep1, rep2, satisfying: rep2[i] = U⁻¹ * rep1[i] * U.

group_inverse(multable::AbstractMatrix{<:Integer})

Compute the inverse of the group elements.

Outputs:

ginv : Vector of indices.

irreps(g::FiniteGroup; χ::AbstractVector)

Get the irreducible representations.

krylov_space(mats::AbstractVector{<:AbstractMatrix}, v0::AbstractVector, n::Integer; tol)

Find the krylov space of the group action from initial vector v0.

Direct sum of matrices or representations.

proj_reps(g, coeff, p; R, tol)

Calculate the projective representation of g with coefficients coeff.

Inputs:

g : Finite group object. coeff : Coefficients represented by an integer matrix. p : Modulus of the the integer. R : Real or not, default = false. tol : Tolerance, default = 1e-7.

Transform matrix from a (reducible) representation to a given irrep.

For a representation D(g) and irrep d(g), find S that S⁺⋅D(g)⋅S = d(g)

Find a list of projection Sᵢ that Sᵢ⁺⋅D(g)⋅Sᵢ = dᵢ(g), where {dᵢ} is a list of irreducible representations as an input.

real_irreps(g::AbstractFiniteGroup)

Get all irreducible real representations of g.

real_rep(r::AbstractVector{<:AbstractMatrix})

Return real representation for a complex-value real representation.

For a representation D(g), it is a real representation means that S⋅D̄(g)⋅S⁺ = D(g) => Sᵀ = S, Find the sqaure root of S, i.e., S = W⋅W => W⋅D̄(t)⋅W⁺ = W⁺⋅D(g)⋅W The real representation is W⁺⋅D(g)⋅W.

regular_rep(g::AbstractFiniteGroup)

Return regular representation.

Group the spectrum into degenerate sets.

transform_rep(U, D1, V)

Transform the basis of the representationc D1.

The inputs is U, D1, and V, the output is: D₂(g) = U⋅D₁(g)⋅V

Convert a representation to unitary representation.

Construct the matrix H = ∑D⁺(g)D(g) = v⋅e⋅v⁺ = (X⋅X⁺)⁻¹ = (X⁻¹)⁺⋅X⁻¹ => X = v⋅(√e)⁻¹⋅v⁺, X⁻¹ = v⋅(√e)⋅v⁺ The new representation D'(g) := X⁻¹⋅D(g)⋅X is unitary: D'⁺(g)⋅D'(g) = X⁺⋅D(g)⋅(X⁻¹)⁺⋅X⁻¹⋅D(g)⋅X = X⁺⋅H⋅X = I.

Eigen decomposition of unitary matrix.

The eigen vectors are unitary.

Split the vector space according to the split of the eigen values.