Clarification on irreducible representations and basis extraction

[kneshat]

Hi,

I have been using the SymbolicWedderburn.jl package and have some questions regarding the decomposition and basis extraction.

Code:

using SymbolicWedderburn
using PermutationGroups
using DynamicPolynomials

const N = 8
@polyvar x[1:N]
f = sum(x.^4) + sum(x[i]^2 * x[j]^2 for i in 1:8 for j in i+1:8)+1
MyGroup=PermGroup([perm"(1,2,4,7)(3,6,8,5)", perm"(1,3,4,8)(2,5,7,6)"])
MyAction=VariablePermutation(x)


max_deg = DynamicPolynomials.maxdegree(f)
basis_full = DynamicPolynomials.monomials(x, 0:max_deg)
basis_half = DynamicPolynomials.monomials(x, 0:max_deg÷2)

wd = WedderburnDecomposition(Float64, MyGroup, MyAction, basis_full, basis_half)
function get_irrep_degrees(wd::WedderburnDecomposition)
    ds = direct_summands(wd)
    return SymbolicWedderburn.degree.(ds)
end

# Output components
#println("Basis: ", wd.basis)
#println("Invariant Vectors: ", wd.invariants)
#println("Direct Summands: ", wd.Uπs)
#println("Homomorphism: ", wd.hom)
println("Degrees of irreducible representations: ", get_irrep_degrees(wd))
println(wd)

Result:

Degrees of irreducible representations: [1, 1, 1, 1, 2]
Wedderburn Decomposition into 66 orbits and 5 summands of sizes
[7, 6, 6, 6, 20]

Questions:

Understanding Irrep Blocks:
1- How should I understand which block corresponds to which irreducible representation? Here I have three blocks of size 6. Does each block correspond to each irrep, or do two blocks correspond to one irrep of degree 2? I am asking this in general, not just for this specific case.

Irrep Degrees Over Reals vs Complex Numbers:
2- The underlying group here is the quaternion group 𝑄8. This group has irreps of degrees [1, 1, 1, 1, 2] over 𝐶 and degrees [1, 1, 1, 1, 4] over 𝑅. I thought this package considered irreps over reals, but it seems it considers irreps over complex numbers due to the result. Is that so?

Extracting the Basis After Symmetry Reduction:
3- The basis is a monomial basis before symmetry reduction. How can I extract the basis after symmetry reduction? I suppose the extracted basis is no longer monomial but involves polynomials.

[kalmarek]

1. Each of the block originates at one isotypical summand and holds its corresponding character in character (private) field.

These blocks may be projected further (by finding minimal rank projections in the isotypical image) so that they no longer correspond to the full isotypical summand, however it is always possible to reconstruct the full one by taking an orbit of each (row) vector in a summand. If the projection failed to be rank one, you'll see duplicates of vector subspaces spanned by orbits of vectors.

2. the quaternionic character + action resulted in real projection, so no modification was performed on the character.

3. The shortest way is

SW.image_basis(direct_summands(wd)[end]) * basis_half

As you can see the returned basis is real, even if we consider irreps over ℂ.

Question for you: I don't know a formula for a character of quaternionic type which will turn it into a canonically chosen (??) real character. Do you know such formula?

[kneshat]

I think those numbers do not correspond to the full isotypical summands. I think they indeed correspond to minimal blocks. Let me give you a better example, a polynomial which has a symmetry of $A_4$.

using SymbolicWedderburn
using PermutationGroups
using DynamicPolynomials


@polyvar x[1:8]
f = sum(x.^4) +sum(x[i]^2 * x[j]^2 for i in 1:8 for j in i+1:8)
+sum(x[i] * x[j] * x[k] * x[l] for i in 1:8 for j in i+1:N for k in j+1:N for l in k+1:8)
MyGroup=PermGroup([perm"(1,2,3)(5,6,7)", perm"(1,2)(3,4)(5,6)(7,8)"])
MyAction=VariablePermutation(x)


max_deg = DynamicPolynomials.maxdegree(f)
basis_full = DynamicPolynomials.monomials(x, 0:max_deg)
basis_half = DynamicPolynomials.monomials(x, 0:max_deg÷2)

wd = WedderburnDecomposition(Float64, MyGroup, MyAction, basis_full, basis_half)
function get_irrep_degrees(wd::WedderburnDecomposition)
    ds = direct_summands(wd)
    return SymbolicWedderburn.degree.(ds)
end

println("Degrees of irreducible representations: ", get_irrep_degrees(wd))
println(wd)
println("basis_half length: ", length(basis_half))

with the following result:

Degrees of irreducible representations: [1, 2, 3]
Wedderburn Decomposition into 59 orbits and 3 summands of sizes
[9, 6, 10]
basis_half length: 45

As you see, $9+6+10 \ne 45$. So, it seems [9, 6, 10] demonstrates the size of minimal blocks. The theory works well here because we have:
the size of the whole matrix =

$$\sum_{i=1}^m \frac{d_i}{k_i} \times n_i ,$$
where $k_i=$ 1, 2, or 4 for irrep with Frobenius–Schur indicator 1, 0, or -1, respectively, $d_i$ is the dimension of $i^{th}$ real irrep, and $n_i$ is the number of times that it occurs. In our example, we have $\frac{1}{1} \times 9 + \frac{2}{2} \times 6 + \frac{3}{1} \times 10=45$.

Suppose, I do not know the theory, how can I extract how many times an irrep appears? and how many minimal blocks are in one isotypical block?

Question for me: I do not understand your question. Would you explain more?

What you can do with characters of complex irreps when they are real, you can do with characters of real irreps. This is because we can recover one from another. We have three cases:
Each real irrep with Frobenius–Schur indicator 1 corresponds to one complex irrep with the same character, although the representation is over the complex numbers.
Each real irrep with Frobenius–Schur indicator -1 corresponds to one complex irrep whose character is half of the original one. Again here both characters are real.
Each real irrep with Frobenius–Schur indicator 0 corresponds to two non-isomorphic complex irreps. Here, characters of complex irreps are complex and conjugate of each other.

In general, if we have $N_1$ non-isomorphic real irreps with Frobenius–Schur indicator 1, $N_2$ non-isomorphic real irrep with Frobenius–Schur indicator -1, and $N_3$ non-isomorphic real irreps with Frobenius–Schur indicator 0, then we have $N_1 +N_2 +2N_3$ non-isomorphic complex irreps.

So, if the character corresponds to irrep with Frobenius–Schur indicator 1, do nothing, if it corresponds to irrep with Frobenius–Schur indicator -1, divide it by two.

[kalmarek]

Each block corresponds to an irreducible character, i.e. its image lies within a single isotypical subspace. Based on parameters and kwargs passed, there might be further projections applied. You may consult the docstrings of SW.SymbolicWedderburn and SW.symmetry_adapted_basis.

You can use SW.multiplicity, SW.degree and SW.issimple (in search for better name? isminimal?) to obtain information from a SW.DirectSummand.

In general, if we have N₁ non-isomorphic real irreps with Frobenius–Schur indicator 1, N₂ non-isomorphic real irrep with Frobenius–Schur indicator -1, and N₃ non-isomorphic real irreps with Frobenius–Schur indicator 0, then we have N₁ + N₂ + 2N₃ non-isomorphic complex irreps.

Are you saying it's enough to double the complex irreducible character with FS indicator -1 to obtain the real irreducible character? That's easy enough to implement ;) Would you give it a try? If you do, then you can also tackle reimplementing FS indicator based on powermap stored in character table.

EDIT: The latter is already implemented:

SymbolicWedderburn.jl/src/Characters/chars.jl

Lines 192 to 215 in d1822f2

	If χ is an irreducible `Character`, Frobenius-Schur indicator takes values in
	`{1, 0, -1}` which correspond to the following situations:
	1. `χ` is real-valued and is afforded by an irreducible real representation,
	2. `χ` is a complex character which is not afforded by a real representation, and
	3. `χ` is quaternionic character, i.e. it is real valued, but is not afforded by a
	real representation.
	In cases 2. and 3. `2re(χ) = χ + conj(χ)` corresponds to an irreducible character
	afforded by a real representation.
	"""
	function frobenius_schur(χ::Character)
	@assert isirreducible(χ)
	pmap = powermap(table(χ))
	ι = sum(
	length(c) * χ[pmap[i, 2]] for (i, c) in enumerate(conjugacy_classes(χ))
	)
	ι_int = Int(ι)
	ordG = sum(length, conjugacy_classes(χ))
	d, r = divrem(ι_int, ordG)
	@assert r == 0 "Non integral Frobenius Schur Indicator: $(ι_int) = $d * $ordG + $r"
	return d
	end

So there's a bug with the quaternionic representation, see issue #83, up for you to grab and fix! ;)

[kneshat]

Thank you for pointing out that the FS indicator of complex irreps can be either 1, 0, or -1, but not the FS indicator of real irreps. I have investigated what are the correct terms for some of our concepts. To be precise and correct myself let me write a gentle recap.

Let $G$ be a finite group with complex irreps $W_i$. Let $V$ be a real irrep of $G$. Denote $\chi_{W_i}$ and $\chi_{V}$ the corresponding characters. Each $V$ has three possibilities:

Case 1 $\dim_{\mathbb{R}}\text{End}_G(V)=1$:

In this case, there exists a complex irrep $W_i$ such that $V\otimes_{\mathbb{R}} \mathbb{C}=W_i$.

Here, $\chi_V=\chi_{W_i}$, and the Frobinus-Schur indicator of $W_i$ and $V$ both are 1.

Case 2 $\dim_{\mathbb{R}}\text{End}_G(V)=2$:

In this case, there exist two non-isomorphic complex irreps $W_i$ and $W_j \cong W_i^*$ such that

$V \otimes_{\mathbb{R}} \mathbb{C}=W_i \oplus W_i^*$.

Here, $\chi_{V}=\chi_{W_i}+\bar{\chi}_{W_i}$, and the Frobinus-Schur indicator of $W_i$, $W_j$, and $V$ are all 0.

Case 3: $\dim_{\mathbb{R}}\text{End}_G(V)=4$:

In this case, there exists a complex irrep $W_i$ such that $V \otimes_{\mathbb{R}} \mathbb{C}=W_i \oplus W_i$.

Here, $\chi_V=2 \chi_{W_i}$, and the Frobinus-Schur indicator of $W_i$ is -1, but that of $V$ is -2.

-When we refer to real, complex, or quaternion-type irrep, we may mean irrep $W_i$ with Frobinus-Schur indicator 1, 0, or -1, respectively. We also may mean irrep $V$ with $\dim_{\mathbb{R}}\text{End}_G(V)=$ 1, 2, or 4, respectively. So, It means both in different contexts, as far as I know. It's unfortunate but they can be disambiguated based on whether the author is discussing real or complex representations.

-The Frobenius-Schur indicator makes sense over any ground field.

---

Yes, I think isminimal is a better name, and issimple is confusing since each two-sided minimal ideal in the group algebra is simple, but they do not correspond to the minimal block but they correspond to isotypic blocks.

---

In the following code, I think I get a minimal block, while the issimple says it is not.

using SymbolicWedderburn
using PermutationGroups
using DynamicPolynomials


@polyvar x[1:8]
f = sum(x.^4) +sum(x[i]^2 * x[j]^2 for i in 1:8 for j in i+1:8)
+sum(x[i] * x[j] * x[k] * x[l] for i in 1:8 for j in i+1:N for k in j+1:N for l in k+1:8)
MyGroup=PermGroup([perm"(1,2,3)(5,6,7)", perm"(1,2)(3,4)(5,6)(7,8)"])
MyAction=VariablePermutation(x)

max_deg = DynamicPolynomials.maxdegree(f)
basis_full = DynamicPolynomials.monomials(x, 0:max_deg)
basis_half = DynamicPolynomials.monomials(x, 0:max_deg÷2)

wd = WedderburnDecomposition(Float64, MyGroup, MyAction, basis_full, basis_half)

function get_irrep_degrees(wd::WedderburnDecomposition)
    ds = direct_summands(wd)
    degrees = SymbolicWedderburn.degree.(ds)
    multiplicities = SymbolicWedderburn.multiplicity.(ds)
    minimality = SymbolicWedderburn.issimple.(ds)
    return degrees, multiplicities, minimality
end

function print_block_details(wd::WedderburnDecomposition)
    degrees, multiplicities, minimality = get_irrep_degrees(wd)
    for i in 1:length(degrees)
        println("Block $i (Degree: $(degrees[i]), Multiplicity: $(multiplicities[i]), Minimality: $(minimality[i]))")
        println()
    end
end
print_block_details(wd)
print(wd)

with the result:

Block 1 (Degree: 1, Multiplicity: 9, Minimality: true)

Block 2 (Degree: 2, Multiplicity: 3, Minimality: false)

Block 3 (Degree: 3, Multiplicity: 10, Minimality: true)

Wedderburn Decomposition into 59 orbits and 3 summands of sizes
[9, 6, 10]

Although the multiplicity of the second block is 3 while its size is 6, I believe this block is minimal. Can you really further block diagonlize this block? If you mean minimality in the sense of complex blocks, then of course we can further block diagonlize the second block. However, I believe it is minimal in the sense of real matrices and we cannot further block diagonlize this block.

---

Would you kindly tell me how you calculate a non-central primitive idempotent? Given a group $G$, how can I extract those idempotents?

[kalmarek]

Indeed the second block corresponds to χ₂ + χ₃ and seems to be minimal.
the problem is in projection_rank function which doesn't take care of the degree of character.

Please add the fix and this test-case to tests in your pull request ;)

btw. I've just wrote the following show method for DirectSummands:

function Base.show(io::IO, mime::MIME"text/plain", ds::DirectSummand)
    println(
        io,
        (issimple(ds) ? "" : "non-"),
        "minimal direct summand corresponding to character ",
        ds.character,
    )

    l = 18
    k = 6
    println(io, lpad("multiplicity :", l), lpad(multiplicity(ds), k))
    println(io, lpad("degree :", l), lpad(degree(ds), k))
    return show(io, mime, image_basis(ds))
end

With this function in place the offending summand prints as

julia> direct_summands(wd)[2]
minimal direct summand corresponding to character χ₂ +χ₃
    multiplicity :     3
          degree :     2
6×45 SparseArrays.SparseMatrixCSC{Float64, Int64} with 40 stored entries:
⎡⠀⠀⠀⠀⠀⠁⠛⠘⠋⠀⣀⡀⡀⣀⠀⣀⢀⠀⢀⣀⠀⠀⠀⎤
⎣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠁⠀⠉⠄⠉⠀⣤⠈⠁⢠⡤⠀⎦

A bit more informative than what was before :D If you find it useful, tweak according to your needs and we can add this to the package as well.

Would you kindly tell me how you calculate a non-central primitive idempotent? Given a group , how can I extract those idempotents?

This is described in one of our papers, see my reply to the same question of yours here:
https://discourse.julialang.org/t/symmetry-reduction-documentation/98354/18?u=abulak

In code this is done by minimal_projection_system and for each character minimal_rank_projection. I'd assume that the latter function would also need some changes (or rather bugfixes ;) ) to accommodate for non-irreducible characters...

[kneshat]

I know how we can fix the problem theoretically. We need to divide projectio_rank(ds) by a number which is either 1, 2, or 4 depending on the type of the corresponding irrep. Indeed, this number for real irrep $V$ is $\dim_{\mathbb{R}}(End_G(V))$. In complex representation theory, we know $\chi$ corresponds to complex irrep if and only if $dot(\chi,\chi)=1$. However, this is not true in general. For any representation $V$ over field $K$ where $|G|$ is invertible in $K$, the orthogonality relation implies $dot(\chi_V,\chi_V)=$\dim_K(End_G(V))$. So, for a real irrep character $\chi$, $dot(\chi,\chi)$ is either 1, 2, or 4. I wanted to use this for the implementation, I have tried issimple(ds::DirectSummand) = isone(projection_rank(ds) ÷ dot(character(ds), character(ds))) and issimple(ds::DirectSummand) = isone(projection_rank(ds) / dot(character(ds), character(ds))). They do not work because of the difference between the types of projection_rank(ds) and dot(character(ds), character(ds)). Any hints on how to resolve this would be appreciated.

---

I have read your paper. My problem is I do not understand it fully. I did not understand how you set $\Sigma$ to be a wreath product of $Z_2$ and $S_n$. It is not true that any finite group is a wreath product of $Z_2$ and $S_n$ for some $n$. Isn't it? So, for a given group $G$, how can we consider $G \cong Z_2^n \rtimes S_n$? Is this isomorphism action dependent? Are you saying whenver we have signed permutation representation, we can view $G \cong Z_2^n \rtimes S_n$?

[kalmarek]

dot(χ, χ) will return an element of the field of definition of χ. If you're sure it is an integer at this particular point, you may just Int(…) it. e.g. degree does this to always return and Int.

In the paper we describe the particular "small" idempotents that can be used for this particular G. As you can see these all correspond to trivial/alternating characters of non-normal subgroups of G. And these (or maybe slightly different ones) were computed by minimal_projection_system which just runs over small cyclic subgroups in a brute-force way.

[kneshat]

If I use AP.degree(dot(character(ds), character(ds))) or degree(dot(character(ds), character(ds))), I get nested task error: MethodError: no method matching degree(::Cyclotomics.Cyclotomic{Int64, SparseArrays.SparseVector{Int64, Int64}}). However, Int(dot(character(ds), character(ds))) does not give any error. In this case, WedderburnDecomposition fails to run and I get nested task error: "The dimension of the projection doesn't match with simple summand multiplicity: 4 ≠ 1". What do you suggest? Do you suggest to change

   for (χ, ds) in zip(irr, direct_summands)
        if issimple(ds) &&
           (d = size(ds, 1)) !=
           (e = multiplicity(ds) * sum(multiplicities(χ) .> 0))
            throw(
                "The dimension of the projection doesn't match with simple summand multiplicity: $d ≠ $e",
            )
        end
    end

accordingly? Or do you prefer to adopt another approach?

---

I have some questions:
1- I know irreps of $G_1 \times G_2$ are derived with tensor product and characters of these irreps are simply derived with usual multipication. However, how do you say the minimal system of projections of $\pi \otimes \psi$ has elements $p_{\pi}p_{\psi}$? Is it similar to saying the set of mutually orthogonal non-central primitive elements of the group algebra $K[G_1 \times G_2]$ is derived with the multipication between mutually orthogonal non-central primitive elements of $KG_1$ and that of $KG_2$?

2- Do you know the relation between the cardinality of the set of mutually orthogonal non-central primitive elements with $m_{\pi}=\dim\pi$?

3- My most important confusion is I almost understand how you find such idempotents for $Z_2^n \rtimes S_n$ but how can you consider any group $G$ in the form of $\Sigma=Z_2 \wr S_n$? In subsection 3.3, you explained why $\Sigma=Z_2 \wr S_n$. However, I do not know how any finite groups can be considered $\Sigma$.

I cannot find my answers in Serre's book. If you give me some references, I will go and search for my answers.

---

I am not familiar with the entire literature, but I feel your work on constructing idempotents is very profound. I have been extensively researching how one can construct primitive idempotents and have not found much, even though group algebras\rings are well-established subjects. As far as I have seen, it seems constructing such idempotents in group algebras over finite fields has a significant application on coding theory, and no one has presented a method to construct such elements in the most generality in the context of modular representation theory. They can construct them in group algebras that the underlying group has particular structures. I think people in coding theory may become interested to your work if they are exposed to your paper. Related to our work, I was not able to find anything on the construction of such elements in characteristic zero except
https://www.ams.org/journals/mcom/0000-000-00/S0025-5718-2024-03937-6/

So I am wondering have you seen anything similar? Could you tell me of some references about non-central primitive idempotents in characteristic zero?

[kalmarek]

dot(χ, χ) is in general a cyclotomic number; neither I, nor the package knows what degree of a cyclotomic should be ;D. What I meant is that given that degree of a character is an integer we can safely cast the value χ(id) to Int. The same applies here to dot(χ, χ) which is 1,2, or 4.

Yes, this was a safety check that was correct only as much as issimple was. As we modify/correct what issimple means, we need to change those checks as well.

1. Tensor product of representations correspond to the product of corresponding central idempotents. The same thing works for primitive idempotents of a direct product as well (proof by contradiction).
2. For the applications here we need just one primitive idempotent for every irreducible π, so I never studied this question.
3. In this paper we just construct a set of minimal projections for our specific application (i.e. the specific G). There is no claim of generality there. The method, which is not tied to those groups G, (abstractly) just tries to restrict given irreducible π to larger and larger (non-normal) subgroups H, hoping that the trivial character of H will occur with multiplicity 1 afterwards. This was me re-discovering an idea of an old paper (1965ish?) which I can not find right now, sorry.

---

I don't think I'm the right person to ask those questions. This is the only moment when I touched primitive idempotents in my research (also noting and therefore I am not really competent to answer those questions. Furthermore I no longer work in research mathematics and so I don't feel particularly interested in developing mathematical theories. I hope you understand ;)

[kneshat]

@kalmarek, I have modified issimple and the corresponding safety check succesfully. So, I am wondering if I should add that to my master branch and then commit it in the current pull request (#86) or if I need to add that to a new branch and open a new pull request for that branch?

[kalmarek]

@kneshat let's make it a new branch.
When you're locally on your branch (from #86) you may type git checkout -b kn/correcting_issimple (here kn/correcting_issimple is the name of the new branch -- you are free to pick the name as you want) and commit your changes there. Once you're happy with the changes do git push (setting up the upstream repo as your own) and create a pull/merge request to master branch here.

[kneshat]

After modifying issimple and its corresponding safety check, running runtest.jl gives me the error real: Test Failed at c:\Users\raven\.julia\packages\SymbolicWedderburn\lbiby\test\sa_basis.jl:160 Expression: multiplicity(b) == size(b, 1) || 2 * multiplicity(b) == size(b, 1) for all the groups that involve quaternion-type irreps. So what do you suggest? We can modify this part as well, but I suppose there is no need to do that since the current construction of symmetry-adapted bases is fine. For the cases that involve quaternionic characters, you construct symmetry-adapted bases based on their complex irreps, but one can do so based on their real irreps. I suppose both ways work. If one wants detailed information about blocks and characters, then we need to modify the current scripts. In this situation, what do you suggest?

[kalmarek]

We can modify this part as well, but I suppose there is no need to do that since the current construction of symmetry-adapted bases is fine.

Tests are there not to "prove" that the code is fine now. They are there to make sure that the future us don't brake things that were fine ;)

---

I suggest making the test even more specific by asking for the indicator of the underlying character and testing expected dimensions of issimple summand based on the type of the representation.

[kneshat]

How much specific do you want? I have resolved it by changing lines 159 and 160 from @test multiplicity(b) == size(b, 1) || 2 * multiplicity(b) == size(b, 1) to @test multiplicity(b) == size(b, 1) || 2 * multiplicity(b) == size(b, 1) || 4 * multiplicity(b) == size(b, 1). Is it enough, or do you suggest to add something like @testset "quaternionic"?

[kalmarek]

see #86 (comment)

[kneshat]

using frobenius_schur(b.character) for b in sa_basisR does not work since not all b.character are irreducible in the sense that you defined with the function isirreducible. My two first questions are: did you define isirreducible only for complex characters? What is the difference between issimple and isirreducible?

Now, I am wondering if I need to modify this function so that we can define frobenius_schur for irreducible real characters or not. In theory, frobenius_schur has a meaning for any ground field $K$ that makes $KG$ semisimple. This indicator relates to the possibility that the underlying irrep (not necessarily complex) accepts invariant symmetric bilinear forms and invariant skew-symmetric bilinear forms.

Do you have any other suggestion instead of checking frobenius_schur(b.character)? So that we can proceed without modifying isirreducible and frobenius_schur