%% for a long time these were red and blue by default, %% now black, but keep variables to overwrite \definecolor{FuncColor}{rgb}{0.0,0.0,0.0} %% strange name because of pdflatex bug: \definecolor{Chapter }{rgb}{0.0,0.0,0.0} \definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}
% write page numbers to a .pnr log file for online help \newwrite\pagenrlog \immediate\openout\pagenrlog =\jobname.pnr \immediate\write\pagenrlog{PAGENRS := [} \newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}} %% were never documented, give conflicts with some additional packages
\newcommand{\GAP}{\textsf{GAP}}
%% nicer description environments, allows long labels \usepackage{enumitem} \setdescription{style=nextline}
\section{\textcolor{Chapter }{Getting started with RepnDecomp}}\label{Chapter_Introduction_Section_Getting_started_with_RepnDecomp} \logpage{[ 1, 1, 0 ]} \hyperdef{L}{X789233A47A277072}{}
{
This package allows computations of various decompositions of a representation $\rho : G \to GL(V)$ where $G$ is finite and $V$ is a finite\texttt{\symbol{45}}dimensional $\mathbb{C}$\texttt{\symbol{45}}vector space.
To install this package, refer to the installation instructions in the README
file in the source code. It is located here: \href{https://github.com/gap-packages/RepnDecomp/blob/master/README.md} {\texttt{https://github.com/gap\texttt{\symbol{45}}packages/RepnDecomp/blob/master/README.md}}. }
\subsection{\textcolor{Chapter }{Note on what is meant by a representation}}\label{Chapter_Introduction_Section_Getting_started_with_RepnDecomp_Subsection_Note_on_what_is_meant_by_a_representation} \logpage{[ 1, 1, 2 ]} \hyperdef{L}{X792C0F507B4A3B89}{}
{
Throughout this documentation, mathematical terminology is used e.g.
representation. It is clear what is meant mathematically, but it is not
entirely clear what is meant in terms of GAP types \texttt{\symbol{45}} what
are you supposed to pass in when I say "pass in a representation".
Occasionally I will not even mention what we are passing in and assume the
reader knows that \mbox{\texttt{\mdseries\slshape rho}} or $\rho$ refers to a representation. A representation we can use is, in GAP, a
homomorphism from a finite group to a matrix group where all matrices have
coefficients in a cyclotomic field (\texttt{Cyclotomics} is the union of all such fields in GAP). You can check whether something you
want to pass is suitable with the function \texttt{IsFiniteGroupLinearRepresentation} (\ref{IsFiniteGroupLinearRepresentation:for IsGroupHomomorphism}).
Here's an example of a representation \mbox{\texttt{\mdseries\slshape rho}} in GAP:
The algorithms implemented can be divided into two groups: methods due to
Serre from his book Linear Representations of Finite Groups, and original
methods due to the authors of this package.
The default is to use the algorithms due to Serre. If you pass the option \texttt{method := "alternate"} to a function, it will use the alternate method. Passing the option \texttt{parallel} will try to compute in parallel as much as possible. See the individual
functions for options you can pass.
The main functions implemented in this package are:
For decomposing representations into canonical and irreducible direct
summands:
Let $\rho : G \to GL(V)$ and $\tau : G \to GL(W)$. If there exists a linear map $A : V \to W$ such that for all $g \in G$, $\tau(g)A = A\rho(g)$, this function returns one such $A$. $A$ is the isomorphism between the representations. If the representations are not
isomorphic, then fail is returned.
There are three methods that we can use to compute an isomorphism of linear
representations, you can select one by passing options to the function.
\begin{itemize} \item\texttt{use{\textunderscore}kronecker}: Assumes the matrices are small enough that their Kronecker products can fit
into memory. Uses \texttt{GroupSumBSGS} (\ref{GroupSumBSGS}) and \texttt{KroneckerProduct} to compute an element of the fixed subspace of $\rho\otimes\tau^*$. \end{itemize}
\begin{itemize} \item\texttt{use{\textunderscore}orbit{\textunderscore}sum}: Finds an isomorphism by summing orbits of the the action of $\rho\otimes\tau^*$ on matrices. Note that orbits could be very large, so this could be as bad as
summing over the whole group. \end{itemize}
\begin{itemize} \item The default, sums over the whole group to compute the projection onto the
fixed subspace. \end{itemize}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@G := SymmetricGroup(4);;|
!gapprompt@gap>| !gapinput@irreps := IrreducibleRepresentations(G);;|
!gapprompt@gap>| !gapinput@# rho and tau are isomorphic - they just have a different block order|
!gapprompt@>| !gapinput@rho := DirectSumOfRepresentations([irreps[1], irreps[3], irreps[3]]);;|
!gapprompt@gap>| !gapinput@tau := DirectSumOfRepresentations([irreps[3], irreps[1], irreps[3]]);;|
!gapprompt@gap>| !gapinput@# tau2 is just tau with a basis change - still isomorphic|
!gapprompt@>| !gapinput@B := RandomInvertibleMat(5);;|
!gapprompt@gap>| !gapinput@tau2 := ComposeHomFunction(tau, x -> B^-1 * x * B);;|
!gapprompt@gap>| !gapinput@# using the default implementation|
!gapprompt@>| !gapinput@M := LinearRepresentationIsomorphism(rho, tau);;|
!gapprompt@gap>| !gapinput@IsLinearRepresentationIsomorphism(M, rho, tau);|
true
!gapprompt@gap>| !gapinput@M := LinearRepresentationIsomorphism(tau, tau2);;|
!gapprompt@gap>| !gapinput@IsLinearRepresentationIsomorphism(M, tau, tau2);|
true
!gapprompt@gap>| !gapinput@# using the kronecker sum implementation|
!gapprompt@>| !gapinput@M := LinearRepresentationIsomorphism(tau, tau2 : use_kronecker);;|
!gapprompt@gap>| !gapinput@IsLinearRepresentationIsomorphism(M, tau, tau2);|
true
!gapprompt@gap>| !gapinput@# using the orbit sum implementation|
!gapprompt@>| !gapinput@M := LinearRepresentationIsomorphism(tau, tau2 : use_orbit_sum);;|
!gapprompt@gap>| !gapinput@IsLinearRepresentationIsomorphism(M, tau, tau2);|
true
!gapprompt@gap>| !gapinput@# two distinct irreps are not isomorphic|
!gapprompt@>| !gapinput@M := LinearRepresentationIsomorphism(irreps[1], irreps[2]);|
fail \end{Verbatim}
Gives the same result as \texttt{LinearRepresentationIsomorphism} (\ref{LinearRepresentationIsomorphism}), but this function uses a simpler method which always involves summing over $G$, without using \texttt{GroupSumBSGS} (\ref{GroupSumBSGS}). This might be useful in some cases if computing a good BSGS is difficult.
However, for all cases that have been tested, it is slow (as the name
suggests).
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# Following on from the previous example|
!gapprompt@>| !gapinput@M := LinearRepresentationIsomorphismSlow(rho, tau);;|
!gapprompt@gap>| !gapinput@IsLinearRepresentationIsomorphism(M, rho, tau);|
true \end{Verbatim}
\subsection{\textcolor{Chapter }{AreRepsIsomorphic}} \logpage{[ 2, 2, 1 ]}\nobreak \hyperdef{L}{X86EB9DD586958473}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AreRepsIsomorphic({\mdseries\slshape rho, tau})\index{AreRepsIsomorphic@\texttt{AreRepsIsomorphic}} \label{AreRepsIsomorphic}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
true if \mbox{\texttt{\mdseries\slshape rho}} and \mbox{\texttt{\mdseries\slshape tau}} are isomorphic as representations, false otherwise.
Since representations of finite groups over $\mathbb{C}$ are determined by their characters, it is easy to check whether two
representations are isomorphic by checking if they have the same character. We
try to use characters wherever possible.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# Following on from the previous examples|
!gapprompt@>| !gapinput@# Some isomorphic representations|
!gapprompt@>| !gapinput@AreRepsIsomorphic(rho, tau);|
true
!gapprompt@gap>| !gapinput@AreRepsIsomorphic(rho, tau2);|
true
!gapprompt@gap>| !gapinput@# rho isn't iso to irreps[1] since rho is irreps[1] plus some other stuff|
!gapprompt@>| !gapinput@AreRepsIsomorphic(rho, irreps[1]);|
false \end{Verbatim}
}
\subsection{\textcolor{Chapter }{IsLinearRepresentationIsomorphism}} \logpage{[ 2, 2, 2 ]}\nobreak \hyperdef{L}{X81080E1B7917B361}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsLinearRepresentationIsomorphism({\mdseries\slshape A, rho, tau})\index{IsLinearRepresentationIsomorphism@\texttt{IsLinearRepresentationIsomorphism}} \label{IsLinearRepresentationIsomorphism}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
true if \mbox{\texttt{\mdseries\slshape rho}} and \mbox{\texttt{\mdseries\slshape tau}} are isomorphic as as representations with the isomorphism given by the linear
map \mbox{\texttt{\mdseries\slshape A}}
This function tests if, for all $g \in G$, $A \rho(g) = \tau(g) A$. That is, true is returned iff $A$ is the intertwining operator taking $\rho$ to $\tau$. that:
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# We have already seen this function used heavily in previous examples.|
!gapprompt@>| !gapinput@# If two representations are isomorphic, the following is always true:|
!gapprompt@>| !gapinput@IsLinearRepresentationIsomorphism(LinearRepresentationIsomorphism(rho, tau), rho, tau);|
true
!gapprompt@gap>| !gapinput@# Note: this test is sensitive to ordering:|
!gapprompt@>| !gapinput@IsLinearRepresentationIsomorphism(LinearRepresentationIsomorphism(rho, tau), tau, rho);|
false \end{Verbatim}
\subsection{\textcolor{Chapter }{UnitaryRepresentation}} \logpage{[ 3, 1, 1 ]}\nobreak \hyperdef{L}{X86B2367A79BE5B9F}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{UnitaryRepresentation({\mdseries\slshape rho})\index{UnitaryRepresentation@\texttt{UnitaryRepresentation}} \label{UnitaryRepresentation}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
A record with fields basis{\textunderscore}change and
unitary{\textunderscore}rep such that \mbox{\texttt{\mdseries\slshape rho}} is isomorphic to unitary{\textunderscore}rep, differing by a change of basis
basis{\textunderscore}change. Meaning if $L$ is basis{\textunderscore}change and $\rho_u$ is the unitarised \mbox{\texttt{\mdseries\slshape rho}}, then $\forall g \in G: \; L \rho_u(g) L^{-1} = \rho(g)$.
Unitarises the given representation quickly, summing over the group using a
base and strong generating set and unitarising with \texttt{LDLDecomposition} (\ref{LDLDecomposition}).
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@G := SymmetricGroup(3);;|
!gapprompt@gap>| !gapinput@irreps := IrreducibleRepresentations(G);;|
!gapprompt@gap>| !gapinput@# It happens that we are given unitary irreps, so|
!gapprompt@>| !gapinput@# rho is also unitary (its blocks are unitary)|
!gapprompt@>| !gapinput@rho := DirectSumOfRepresentations([irreps[1], irreps[2]]);;|
!gapprompt@gap>| !gapinput@IsUnitaryRepresentation(rho);|
true
!gapprompt@gap>| !gapinput@# Arbitrary change of basis|
!gapprompt@>| !gapinput@A := [ [ -1, 1 ], [ -2, -1 ] ];;|
!gapprompt@gap>| !gapinput@tau := ComposeHomFunction(rho, x -> A^-1 * x * A);;|
!gapprompt@gap>| !gapinput@# Not unitary, but still isomorphic to rho|
!gapprompt@>| !gapinput@IsUnitaryRepresentation(tau);|
false
!gapprompt@gap>| !gapinput@AreRepsIsomorphic(rho, tau);|
true
!gapprompt@gap>| !gapinput@# Now we unitarise tau|
!gapprompt@>| !gapinput@tau_u := UnitaryRepresentation(tau);;|
!gapprompt@gap>| !gapinput@# We get a record with the unitarised rep:|
!gapprompt@>| !gapinput@AreRepsIsomorphic(tau, tau_u.unitary_rep);|
true
!gapprompt@gap>| !gapinput@AreRepsIsomorphic(rho, tau_u.unitary_rep);|
true
!gapprompt@gap>| !gapinput@# The basis change is also in the record:|
!gapprompt@>| !gapinput@ForAll(G, g -> tau_u.basis_change * Image(tau_u.unitary_rep, g) = Image(tau, g) * tau_u.basis_change);|
true \end{Verbatim}
}
\subsection{\textcolor{Chapter }{IsUnitaryRepresentation}} \logpage{[ 3, 1, 2 ]}\nobreak \hyperdef{L}{X87D121227C027253}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsUnitaryRepresentation({\mdseries\slshape rho})\index{IsUnitaryRepresentation@\texttt{IsUnitaryRepresentation}} \label{IsUnitaryRepresentation}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
Whether \mbox{\texttt{\mdseries\slshape rho}} is unitary, i.e. for all $g \in G$, $\rho(g^{-1}) = \rho(g)^*$ (where $^*$ denotes the conjugate transpose).
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# TODO: this example| \end{Verbatim}
}
\subsection{\textcolor{Chapter }{LDLDecomposition}} \logpage{[ 3, 1, 3 ]}\nobreak \hyperdef{L}{X78F7DFD186A4E7CA}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{LDLDecomposition({\mdseries\slshape A})\index{LDLDecomposition@\texttt{LDLDecomposition}} \label{LDLDecomposition}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
a record with two fields, L and D such that $A = L\mbox{diag}(D)L^*$. $D$ is the $1 \times n$ vector which gives the diagonal matrix $\mbox{diag}(D)$ (where \mbox{\texttt{\mdseries\slshapeA}} is an $n \times n$ matrix).
\begin{Verbatim}[commandchars=!|B,fontsize=\small,frame=single,label=Example]
!gapprompt|gap>B !gapinput|A := [ [ 3, 2*E(3)+E(3)^2, -3 ], [ E(3)+2*E(3)^2, -3, 3 ], [ -3, 3, -6 ] ];;B
!gapprompt|gap>B !gapinput|# A is a conjugate symmetric matrixB
!gapprompt|>B !gapinput|A = ConjugateTranspose@RepnDecomp(A);B
true
!gapprompt|gap>B !gapinput|# Note that A is not symmetric - the LDL decomposition works for anyB
!gapprompt|>B !gapinput|# conjugate symmetric matrix.B
!gapprompt|>B !gapinput|A = TransposedMat(A);B
false
!gapprompt|gap>B !gapinput|decomp := LDLDecomposition(A);;B
!gapprompt|gap>B !gapinput|# The LDL decomposition is such that A = LDL^*, D diagonal, and L lower triangular.B
!gapprompt|>B !gapinput|A = decomp.L * DiagonalMat(decomp.D) * ConjugateTranspose@RepnDecomp(decomp.L);B
true
!gapprompt|gap>B !gapinput|decomp.L[1][2] = 0 and decomp.L[1][3] = 0 and decomp.L[2][3] = 0;B
true \end{Verbatim}
\subsection{\textcolor{Chapter }{IrreducibleDecompositionDixon}} \logpage{[ 3, 2, 1 ]}\nobreak \hyperdef{L}{X8175C1167A31C3D6}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IrreducibleDecompositionDixon({\mdseries\slshape rho})\index{IrreducibleDecompositionDixon@\texttt{IrreducibleDecompositionDixon}} \label{IrreducibleDecompositionDixon}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
a list of irreps in the decomposition of \mbox{\texttt{\mdseries\slshape rho}}
NOTE: this is not implemented yet. Assumes that \mbox{\texttt{\mdseries\slshape rho}} is unitary and uses an algorithm due to Dixon to decompose it into unitary
irreps. }
Tells you if \mbox{\texttt{\mdseries\slshape rho}} is a linear representation of a finite group. The algorithms implemented in
this package work on these homomorphisms only. }
Uses a basic stabiliser chain for $G$ to compute the sum described above. This trick requires \mbox{\texttt{\mdseries\slshape summand}} to be a function (in the GAP sense) that defines a monoid homomorphism (in the
mathematical sense). The computation of the stabiliser chain assumes \mbox{\texttt{\mdseries\slshape G}} is a group. More precisely, if we have the basic stabiliser chain: \[\{1\} = G_1 \leq\ldots\leq G_n = G\]
We traverse the chain from $G_1$ to $G_n$, using the previous sum $G_{i-1}$ to build the sum $G_i$. We do this by using the fact that (writing $f$ for \mbox{\texttt{\mdseries\slshape summand}}) \[\sum_{g \in G_i} f(g) = \sum_{r_j} \left(\sum_{h \in G_{i-1}} f(h)\right)
f(r_j)\]
where the $r_j$ are right coset representatives of $G_{i-1}$ in $G_i$. The condition on \mbox{\texttt{\mdseries\slshape summand}} is satisfied if, for example, it is a linear representation of a group \mbox{\texttt{\mdseries\slshape G}}. }
}
\section{\textcolor{Chapter }{Space\texttt{\symbol{45}}efficient representation of tensors of matrices}}\label{Chapter_Miscellaneous_useful_functions_Section_Space-efficient_representation_of_tensors_of_matrices} \logpage{[ 4, 3, 0 ]} \hyperdef{L}{X86F42D257CFB192D}{}
{
Suppose we have representations of $G$, $\rho$ and $\tau$, with degree $n$ and $m$. If we would like to construct the tensor product representation of $G$, $\rho\otimes\tau$, the usual way to do it would be to take the Kronecker product of the
matrices. This means we now have to store very large $nm \times nm$ matrices for each generator of $G$. This can be avoided by storing the tensor of matrices as pairs, essentially
storing $A \otimes B$ as a pair $(A,B)$ and implementing group operations on top of these, along with some
representation\texttt{\symbol{45}}theoretic functions. It is only possible to
guarantee an economical representation for pure tensors, i.e. matrices of the
form $A \otimes B$. These are closed under group operations, so it is natural to define a group
structure.
\subsection{\textcolor{Chapter }{TensorProductRepLists}} \logpage{[ 4, 5, 1 ]}\nobreak \hyperdef{L}{X841424DF824E258B}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{TensorProductRepLists({\mdseries\slshape list1, list2})\index{TensorProductRepLists@\texttt{TensorProductRepLists}} \label{TensorProductRepLists}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
All possible tensor products given by $\rho\otimes\tau$ where $\rho : G \to\mbox{GL}(V)$ is taken from \mbox{\texttt{\mdseries\slshape list1}} and $\tau : H \to\mbox{GL}(W)$ is taken from \mbox{\texttt{\mdseries\slshape list2}}. The result is then a list of representations of $G \times H$.
}
\subsection{\textcolor{Chapter }{DirectSumOfRepresentations}} \logpage{[ 4, 5, 2 ]}\nobreak \hyperdef{L}{X84EAE3DB7FA8102C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DirectSumOfRepresentations({\mdseries\slshape list})\index{DirectSumOfRepresentations@\texttt{DirectSumOfRepresentations}} \label{DirectSumOfRepresentations}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
Direct sum of the list of representations \mbox{\texttt{\mdseries\slshape list}}
}
\subsection{\textcolor{Chapter }{DegreeOfRepresentation}} \logpage{[ 4, 5, 3 ]}\nobreak \hyperdef{L}{X85147CF97B912CC3}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DegreeOfRepresentation({\mdseries\slshape rho})\index{DegreeOfRepresentation@\texttt{DegreeOfRepresentation}} \label{DegreeOfRepresentation}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
Degree of the representation \mbox{\texttt{\mdseries\slshape rho}}. That is, $\mbox{Tr}(\rho(e_G))$, where $e_G$ is the identity of the group $G$ that \mbox{\texttt{\mdseries\slshape rho}} has as domain.
}
\subsection{\textcolor{Chapter }{PermToLinearRep}} \logpage{[ 4, 5, 4 ]}\nobreak \hyperdef{L}{X7B14287E7BFC548D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PermToLinearRep({\mdseries\slshape rho})\index{PermToLinearRep@\texttt{PermToLinearRep}} \label{PermToLinearRep}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
Linear representation $\rho$ isomorphic to the permutation representation \mbox{\texttt{\mdseries\slshape rho}}.
}
\subsection{\textcolor{Chapter }{IsOrthonormalSet}} \logpage{[ 4, 5, 5 ]}\nobreak \hyperdef{L}{X7E67A4817A5E4879}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsOrthonormalSet({\mdseries\slshape S, prod})\index{IsOrthonormalSet@\texttt{IsOrthonormalSet}} \label{IsOrthonormalSet}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
Whether \mbox{\texttt{\mdseries\slshape S}} is an orthonormal set with respect to the inner product \mbox{\texttt{\mdseries\slshape prod}}.
\section{\textcolor{Chapter }{Block diagonalizing}}\label{Chapter_Computing_decompositions_of_representations_Section_Block_diagonalizing} \logpage{[ 5, 1, 0 ]} \hyperdef{L}{X7E29883984400D2C}{}
{
Given a representation $\rho : G \to GL(V)$, it is often desirable to find a basis for $V$ that block diagonalizes each $\rho(g)$ with the block sizes being as small as possible. This speeds up matrix algebra
operations, since they can now be done block\texttt{\symbol{45}}wise.
Let $G$ have irreducible representations $\rho_i$, with dimension $d_i$ and multiplicity $m_i$. The basis returned by this operation gives each $\rho(g)$ as a block diagonal matrix which has $m_i$ blocks of size $d_i \times d_i$ for each $i$. }
\subsection{\textcolor{Chapter }{BlockDiagonalRepresentation}} \logpage{[ 5, 1, 2 ]}\nobreak \hyperdef{L}{X86EB837579C1416D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BlockDiagonalRepresentation({\mdseries\slshape rho})\index{BlockDiagonalRepresentation@\texttt{BlockDiagonalRepresentation}} \label{BlockDiagonalRepresentation}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
Representation of $G$ isomorphic to $\rho$ where the images $\rho(g)$ are block diagonalized.
This is just a convenience operation that uses \texttt{BlockDiagonalBasisOfRepresentation} (\ref{BlockDiagonalBasisOfRepresentation}) to calculate the basis change matrix and applies it to put $\rho$ into the block diagonalised form. }
}
\section{\textcolor{Chapter }{Algorithms due to the authors}}\label{Chapter_Computing_decompositions_of_representations_Section_Algorithms_due_to_the_authors} \logpage{[ 5, 2, 0 ]} \hyperdef{L}{X863A16A179A7486B}{}
{
\subsection{\textcolor{Chapter }{REPN{\textunderscore}ComputeUsingMyMethod (for IsGroupHomomorphism)}} \logpage{[ 5, 2, 1 ]}\nobreak \hyperdef{L}{X831574AD864C94A8}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{REPN{\textunderscore}ComputeUsingMyMethod({\mdseries\slshape rho})\index{REPN{\textunderscore}ComputeUsingMyMethod@\texttt{REP}\-\texttt{N{\textunderscore}}\-\texttt{Compute}\-\texttt{Using}\-\texttt{My}\-\texttt{Method}!for IsGroupHomomorphism} \label{REPNuScoreComputeUsingMyMethod:for IsGroupHomomorphism}
}\hfill{\scriptsize (attribute)}}\\ \textbf{\indent Returns:\ }
A record in the same format as \texttt{REPN{\textunderscore}ComputeUsingSerre} (\ref{REPNuScoreComputeUsingSerre:for IsGroupHomomorphism})
Computes the same values as \texttt{REPN{\textunderscore}ComputeUsingSerre} (\ref{REPNuScoreComputeUsingSerre:for IsGroupHomomorphism}), taking the same options. The heavy lifting of this method is done by \texttt{LinearRepresentationIsomorphism} (\ref{LinearRepresentationIsomorphism}), where there are some further options that can be passed to influence
algorithms used.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@G := SymmetricGroup(4);;|
!gapprompt@gap>| !gapinput@irreps := IrreducibleRepresentations(G);;|
!gapprompt@gap>| !gapinput@rho := DirectSumOfRepresentations([irreps[4], irreps[5]]);;|
!gapprompt@gap>| !gapinput@# Jumble rho up a bit so it's not so easy for the library.|
!gapprompt@>| !gapinput@A := [ [ 3, -3, 2, -4, 0, 0 ], [ 4, 0, 1, -5, 1, 0 ], [ -3, -1, -2, 4, -1, -2 ],|
!gapprompt@>| !gapinput@ [ 4, -4, -1, 5, -3, -1 ], [ 3, -2, 1, 0, 0, 0 ], [ 4, 2, 4, -1, -2, 1 ] ];;|
!gapprompt@gap>| !gapinput@rho := ComposeHomFunction(rho, B -> A^-1 * B * A);;|
!gapprompt@gap>| !gapinput@# We've constructed rho from two degree 3 irreps, so there are a few|
!gapprompt@>| !gapinput@# things we can check for correctness:|
!gapprompt@>| !gapinput@decomposition := REPN_ComputeUsingMyMethod(rho);;|
!gapprompt@gap>| !gapinput@# Two distinct irreps, so the centralizer has dimension 2|
!gapprompt@>| !gapinput@Length(decomposition.centralizer_basis) = 2;|
true
!gapprompt@gap>| !gapinput@# Two distinct irreps i.e. two invariant subspaces|
!gapprompt@>| !gapinput@Length(decomposition.decomposition) = 2;|
true
!gapprompt@gap>| !gapinput@# All subspaces are dimension 3|
!gapprompt@>| !gapinput@ForAll(decomposition.decomposition, Vs -> Length(Vs) = 1 and Dimension(Vs[1]) = 3);|
true
!gapprompt@gap>| !gapinput@# And finally, check that the block diagonalized representation|
!gapprompt@>| !gapinput@# computed is actually isomorphic to rho:|
!gapprompt@>| !gapinput@AreRepsIsomorphic(rho, decomposition.diagonal_rep);|
true \end{Verbatim}
}
\subsection{\textcolor{Chapter }{REPN{\textunderscore}ComputeUsingMyMethodCanonical (for IsGroupHomomorphism)}} \logpage{[ 5, 2, 2 ]}\nobreak \hyperdef{L}{X7DB659DB7E48D502}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{REPN{\textunderscore}ComputeUsingMyMethodCanonical({\mdseries\slshape rho})\index{REPN{\textunderscore}ComputeUsingMyMethodCanonical@\texttt{REP}\-\texttt{N{\textunderscore}}\-\texttt{Compute}\-\texttt{Using}\-\texttt{My}\-\texttt{Method}\-\texttt{Canonical}!for IsGroupHomomorphism} \label{REPNuScoreComputeUsingMyMethodCanonical:for IsGroupHomomorphism}
}\hfill{\scriptsize (attribute)}}\\ \textbf{\indent Returns:\ }
A record in the same format as \texttt{REPN{\textunderscore}ComputeUsingMyMethod} (\ref{REPNuScoreComputeUsingMyMethod:for IsGroupHomomorphism}).
Performs the same computation as \texttt{REPN{\textunderscore}ComputeUsingMyMethod} (\ref{REPNuScoreComputeUsingMyMethod:for IsGroupHomomorphism}), but first splits the representation into canonical summands using \texttt{CanonicalDecomposition} (\ref{CanonicalDecomposition}). This might reduce the size of the matrices we need to work with
significantly, so could be much faster.
If the option \texttt{parallel} is given, the decomposition of canonical summands into irreps is done in
parallel, which could be much faster.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# This is the same example as before, but splits into canonical|
!gapprompt@>| !gapinput@# summands internally. It gives exactly the same results, up to|
!gapprompt@>| !gapinput@# isomorphism.|
!gapprompt@>| !gapinput@other_decomposition := REPN_ComputeUsingMyMethodCanonical(rho);;|
!gapprompt@gap>| !gapinput@Length(other_decomposition.centralizer_basis) = 2;|
true
!gapprompt@gap>| !gapinput@Length(other_decomposition.decomposition) = 2;|
true
!gapprompt@gap>| !gapinput@ForAll(other_decomposition.decomposition, Vs -> Length(Vs) = 1 and Dimension(Vs[1]) = 3);|
true
!gapprompt@gap>| !gapinput@AreRepsIsomorphic(rho, other_decomposition.diagonal_rep);|
true \end{Verbatim}
}
}
\section{\textcolor{Chapter }{Algorithms due to Serre}}\label{Chapter_Computing_decompositions_of_representations_Section_Algorithms_due_to_Serre} \logpage{[ 5, 3, 0 ]} \hyperdef{L}{X7C22F13E80A74438}{}
{
Note: all computation in this section is actually done in the function \texttt{REPN{\textunderscore}ComputeUsingSerre} (\ref{REPNuScoreComputeUsingSerre:for IsGroupHomomorphism}), the other functions are wrappers around it.
\subsection{\textcolor{Chapter }{CanonicalDecomposition}} \logpage{[ 5, 3, 1 ]}\nobreak \hyperdef{L}{X7E95B0367992BEC4}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CanonicalDecomposition({\mdseries\slshape rho})\index{CanonicalDecomposition@\texttt{CanonicalDecomposition}} \label{CanonicalDecomposition}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
List of vector spaces $V_i$, each $G$\texttt{\symbol{45}}invariant and a direct sum of isomorphic irreducibles.
That is, for each $i$, $V_i \cong\oplus_j W_i$ (as representations) where $W_i$ is an irreducible $G$\texttt{\symbol{45}}invariant vector space.
Computes the canonical decomposition of $V$ into $\oplus_i\;V_i$ using the formulas for projections $V \to V_i$ due to Serre. You can pass in the option \texttt{irreps} with a list of irreps of $G$, and this will be used instead of computing a complete list ourselves. If you
already know which irreps will appear in $\rho$, for instance, this will save time.
\begin{Verbatim}[commandchars=!|A,fontsize=\small,frame=single,label=Example]
!gapprompt|gap>A !gapinput|# This is the trivial groupA
!gapprompt|>A !gapinput|G := Group(());;A
!gapprompt|gap>A !gapinput|# The trivial group has only one representation per degree, so aA
!gapprompt|>A !gapinput|# degree d representation decomposes into a single canonical summandA
!gapprompt|>A !gapinput|# containing the whole spaceA
!gapprompt|>A !gapinput|rho := FuncToHom@RepnDecomp(G, g -> IdentityMat(3));;A
!gapprompt|gap>A !gapinput|canonical_summands_G := CanonicalDecomposition(rho);A
[ ( Cyclotomics^3 ) ]
!gapprompt|gap>A !gapinput|# More interesting example, S_3A
!gapprompt|>A !gapinput|H := SymmetricGroup(3);;A
!gapprompt|gap>A !gapinput|# The standard representation: a permutation to the correspondingA
!gapprompt|>A !gapinput|# permutation matrix.A
!gapprompt|>A !gapinput|tau := FuncToHom@RepnDecomp(H, h -> PermutationMat(h, 3));;A
!gapprompt|gap>A !gapinput|# Two canonical summands corresponding to the degree 2 andA
!gapprompt|>A !gapinput|# trivial irreps (in that order)A
!gapprompt|>A !gapinput|List(CanonicalDecomposition(tau), Dimension);A
[ 2, 1 ] \end{Verbatim}
}
\subsection{\textcolor{Chapter }{IrreducibleDecomposition}} \logpage{[ 5, 3, 2 ]}\nobreak \hyperdef{L}{X795C63F386C45308}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IrreducibleDecomposition({\mdseries\slshape rho})\index{IrreducibleDecomposition@\texttt{IrreducibleDecomposition}} \label{IrreducibleDecomposition}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
List of vector spaces $W_j$ such that $V = \oplus_j W_j$ and each $W_j$ is an irreducible $G$\texttt{\symbol{45}}invariant vector space.
Computes the decomposition of $V$ into irreducible subprepresentations.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# The trivial group has 1 irrep of degree 1, so rho decomposes into 3|
!gapprompt@>| !gapinput@# lines.|
!gapprompt@>| !gapinput@irred_decomp_G := IrreducibleDecomposition(rho);|
[ rec( basis := [ [ 1, 0, 0 ] ] ), rec( basis := [ [ 0, 1, 0 ] ] ),
rec( basis := [ [ 0, 0, 1 ] ] ) ]
!gapprompt@gap>| !gapinput@# The spaces are returned in this format - explicitly keeping the|
!gapprompt@>| !gapinput@# basis - since this basis block diagonalises rho into the irreps,|
!gapprompt@>| !gapinput@# which are the smallest possible blocks. This is more obvious with|
!gapprompt@>| !gapinput@# H.|
!gapprompt@>| !gapinput@irred_decomp_H := IrreducibleDecomposition(tau);|
[ rec( basis := [ [ 1, 1, 1 ] ] ),
rec( basis := [ [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ] ) ]
!gapprompt@gap>| !gapinput@# Using the basis vectors given there block diagonalises tau into|
!gapprompt@>| !gapinput@# the two blocks corresponding to the two irreps:|
!gapprompt@>| !gapinput@nice_basis := [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ];;|
!gapprompt@gap>| !gapinput@tau_diag := ComposeHomFunction(tau, X -> nice_basis^-1 * X * nice_basis);|
[ (1,2,3), (1,2) ] -> [ [ [ 1, 0, 0 ], [ 0, E(3), 0 ], [ 0, 0, E(3)^2 ] ],
[ [ 1, 0, 0 ], [ 0, 0, E(3)^2 ], [ 0, E(3), 0 ] ] ] \end{Verbatim}
}
\subsection{\textcolor{Chapter }{IrreducibleDecompositionCollected}} \logpage{[ 5, 3, 3 ]}\nobreak \hyperdef{L}{X87E91CBE7992D126}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IrreducibleDecompositionCollected({\mdseries\slshape rho})\index{IrreducibleDecompositionCollected@\texttt{IrreducibleDecompositionCollected}} \label{IrreducibleDecompositionCollected}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
List of lists $V_i$ of vector spaces $V_{ij}$ such that $V = \oplus_i\oplus_j V_{ij}$ and $V_{ik} \cong V_{il}$ for all $i$, $k$ and $l$ (as representations).
Computes the decomposition of $V$ into irreducible subrepresentations, grouping together the isomorphic
subrepresentations. }
\subsection{\textcolor{Chapter }{REPN{\textunderscore}ComputeUsingSerre (for IsGroupHomomorphism)}} \logpage{[ 5, 3, 4 ]}\nobreak \hyperdef{L}{X7C1CF0547D72D354}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{REPN{\textunderscore}ComputeUsingSerre({\mdseries\slshape rho})\index{REPN{\textunderscore}ComputeUsingSerre@\texttt{REP}\-\texttt{N{\textunderscore}}\-\texttt{Compute}\-\texttt{Using}\-\texttt{Serre}!for IsGroupHomomorphism} \label{REPNuScoreComputeUsingSerre:for IsGroupHomomorphism}
}\hfill{\scriptsize (attribute)}}\\ \textbf{\indent Returns:\ }
A record, in the format described below
This function does all of the computation and (since it is an attribute) saves
the results. Doing all of the calculations at the same time ensures
consistency when it comes to irrep ordering, block ordering and basis
ordering. There is no canonical ordering of irreps, so this is crucial.
\mbox{\texttt{\mdseries\slshape irreps}} is the complete list of irreps involved in the direct sum decomposition of \mbox{\texttt{\mdseries\slshape rho}}, this can be given in case the default (running Dixon's algorithm) is too
expensive, or e.g. you don't want representations over Cyclotomics.
The return value of this function is a record with fields:
\begin{itemize} \item\texttt{basis}: The basis that block diagonalises $\rho$, see \texttt{BlockDiagonalBasisOfRepresentation} (\ref{BlockDiagonalBasisOfRepresentation}). \end{itemize}
\begin{itemize} \item\texttt{diagonal{\textunderscore}rep}: $\rho$, block diagonalised with the basis above. See \texttt{BlockDiagonalRepresentation} (\ref{BlockDiagonalRepresentation}) \end{itemize}
\begin{itemize} \item\texttt{decomposition}: The irreducible $G$\texttt{\symbol{45}}invariant subspaces, collected according to isomorphism,
see \texttt{IrreducibleDecompositionCollected} (\ref{IrreducibleDecompositionCollected}) \end{itemize}
\begin{itemize} \item\texttt{centralizer{\textunderscore}basis}: An orthonormal basis for the centralizer ring of $\rho$, written in block form. See \texttt{CentralizerBlocksOfRepresentation} (\ref{CentralizerBlocksOfRepresentation}) \end{itemize}
Pass the option \texttt{parallel} for the computations per\texttt{\symbol{45}}irrep to be done in parallel.
Pass the option \texttt{irreps} with the complete list of irreps of $\rho$ to avoid recomputing this list (could be very expensive)
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# Does the same thing we have done in the examples above, but all in|
!gapprompt@>| !gapinput@# one step, with as many subcomputations reused as possible|
!gapprompt@>| !gapinput@REPN_ComputeUsingSerre(tau);|
rec( basis := [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ],
centralizer_basis := [ [ [ [ 1 ] ], [ [ 0, 0 ], [ 0, 0 ] ] ],
[ [ [ 0 ] ], [ [ 1, 0 ], [ 0, 1 ] ] ] ],
decomposition := [ [ rec( basis := [ [ 1, 1, 1 ] ] ) ], [ ],
[ rec( basis := [ [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ] ) ] ],
diagonal_rep := [ (1,2,3), (1,2) ] ->
[ [ [ 1, 0, 0 ], [ 0, E(3), 0 ], [ 0, 0, E(3)^2 ] ],
[ [ 1, 0, 0 ], [ 0, 0, E(3)^2 ], [ 0, E(3), 0 ] ] ] )
!gapprompt@gap>| !gapinput@# You can also do the computation in parallel:|
!gapprompt@>| !gapinput@REPN_ComputeUsingSerre(tau : parallel);;|
!gapprompt@gap>| !gapinput@# Or specify the irreps if you have already computed them:|
!gapprompt@>| !gapinput@irreps_H := IrreducibleRepresentations(H);;|
!gapprompt@gap>| !gapinput@REPN_ComputeUsingSerre(tau : irreps := irreps_H);;| \end{Verbatim}
\section{\textcolor{Chapter }{Finding a basis for the centralizer}}\label{Chapter_Centralizer_commutant_rings_Section_Finding_a_basis_for_the_centralizer} \logpage{[ 6, 1, 0 ]} \hyperdef{L}{X7E70A3D881CD5FFA}{}
{
\subsection{\textcolor{Chapter }{CentralizerBlocksOfRepresentation}} \logpage{[ 6, 1, 1 ]}\nobreak \hyperdef{L}{X7901B6A7860D35C3}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CentralizerBlocksOfRepresentation({\mdseries\slshape rho})\index{CentralizerBlocksOfRepresentation@\texttt{CentralizerBlocksOfRepresentation}} \label{CentralizerBlocksOfRepresentation}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
List of vector space generators for the centralizer ring of $\rho(G)$, written in the basis given by \texttt{BlockDiagonalBasisOfRepresentation} (\ref{BlockDiagonalBasisOfRepresentation}). The matrices are given as a list of blocks.
Let $G$ have irreducible representations $\rho_i$ with multiplicities $m_i$. The centralizer has dimension $\sum_i m_i^2$ as a $\mathbb{C}$\texttt{\symbol{45}}vector space. This function gives the minimal number of
generators required.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@G := DihedralGroup(8);;|
!gapprompt@gap>| !gapinput@irreps := IrreducibleRepresentations(G);;|
!gapprompt@gap>| !gapinput@# rho is the sum of two isomorphic degree 1 irreps, and a degree|
!gapprompt@>| !gapinput@# 2 irrep.|
!gapprompt@>| !gapinput@rho := DirectSumOfRepresentations([irreps[4], irreps[4], irreps[5]]);;|
!gapprompt@gap>| !gapinput@# Compute a basis for the centralizer (in blocks)|
!gapprompt@>| !gapinput@cent_basis_blocks := CentralizerBlocksOfRepresentation(rho);;|
!gapprompt@gap>| !gapinput@# Verify that the dimension is the sum of the multiplicities squared,|
!gapprompt@>| !gapinput@# in this case 2^2 + 1 = 5.|
!gapprompt@>| !gapinput@Length(cent_basis_blocks) = 5;|
true \end{Verbatim}
}
\subsection{\textcolor{Chapter }{CentralizerOfRepresentation}} \logpage{[ 6, 1, 2 ]}\nobreak \hyperdef{L}{X86B19E2B877121E9}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CentralizerOfRepresentation({\mdseries\slshape arg})\index{CentralizerOfRepresentation@\texttt{CentralizerOfRepresentation}} \label{CentralizerOfRepresentation}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
List of vector space generators for the centralizer ring of $\rho(G)$.
This gives the same result as \texttt{CentralizerBlocksOfRepresentation} (\ref{CentralizerBlocksOfRepresentation}), but with the matrices given in their entirety: not as lists of blocks, but
as full matrices.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# This is the actual basis for the centralizer.|
!gapprompt@>| !gapinput@cent_basis := CentralizerOfRepresentation(rho);;|
!gapprompt@gap>| !gapinput@# All matrices in the span should commute with the image of rho.|
!gapprompt@>| !gapinput@ForAll(G, g -> ForAll(cent_basis, M -> Image(rho, g)*M = M*Image(rho,g)));|
true \end{Verbatim}
}
}
\section{\textcolor{Chapter }{Using the centralizer for computations}}\label{Chapter_Centralizer_commutant_rings_Section_Using_the_centralizer_for_computations} \logpage{[ 6, 2, 0 ]} \hyperdef{L}{X83C4F8C17DA976EE}{}
{
\subsection{\textcolor{Chapter }{ClassSumCentralizer}} \logpage{[ 6, 2, 1 ]}\nobreak \hyperdef{L}{X87E5BAEB82DC00C3}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ClassSumCentralizer({\mdseries\slshape rho, class, cent{\textunderscore}basis})\index{ClassSumCentralizer@\texttt{ClassSumCentralizer}} \label{ClassSumCentralizer}
}\hfill{\scriptsize (function)}}\\ \textbf{\indent Returns:\ }
$\sum_{s \in t^G} \rho(s)$, where $t$ is a representative of the conjugacy class \mbox{\texttt{\mdseries\slshape class}} of $G$.
We require that \mbox{\texttt{\mdseries\slshape rho}} is unitary. Uses the given orthonormal basis (with respect to the inner
product $\langle A, B \rangle = \mbox{Trace}(AB^*)$) for the centralizer ring of \mbox{\texttt{\mdseries\slshape rho}} to calculate the sum of the conjugacy class \mbox{\texttt{\mdseries\slshape class}} quickly, i.e. without summing over the class.
NOTE: Orthonormality of \mbox{\texttt{\mdseries\slshape cent{\textunderscore}basis}} and unitarity of \mbox{\texttt{\mdseries\slshape rho}} are checked. See \texttt{ClassSumCentralizerNC} (\ref{ClassSumCentralizerNC}) for a version of this function without checks. The checks are not very
expensive, so it is recommended you use the function with checks.
\begin{Verbatim}[commandchars=!|E,fontsize=\small,frame=single,label=Example]
!gapprompt|gap>E !gapinput|# Now we have a basis for the centralizer, we can sum a conjugacy classE
!gapprompt|>E !gapinput|# of G.E
!gapprompt|>E !gapinput|class := List(ConjugacyClasses(G)[3]);;E
!gapprompt|gap>E !gapinput|# We can do the computation naively, with no centralizer basis given:E
!gapprompt|>E !gapinput|sum1 := ClassSumCentralizer(rho, class, fail);;E
!gapprompt|gap>E !gapinput|# Before summing with th centralizer basis given, we need toE
!gapprompt|>E !gapinput|# orthonormalize it. It's already orthogonal, but not normal:E
!gapprompt|>E !gapinput|orth_basis := OrthonormalBasis@RepnDecomp(cent_basis);;E
!gapprompt|gap>E !gapinput|IsOrthonormalSet(orth_basis, InnerProduct@RepnDecomp);E
true
!gapprompt|gap>E !gapinput|# And with the centralizer given, should be more efficient in certainE
!gapprompt|>E !gapinput|# cases (small degree, low multiplicities, but very large group)E
!gapprompt|>E !gapinput|sum2 := ClassSumCentralizer(rho, class, orth_basis);;E
!gapprompt|gap>E !gapinput|# Should be the same:E
!gapprompt|>E !gapinput|sum1 = sum2;E
true \end{Verbatim}
The same as \texttt{ClassSumCentralizer} (\ref{ClassSumCentralizer}), but does not check the basis for orthonormality or the representation for
unitarity.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@# The very same as the above, but with no checks on orthonormality.|
!gapprompt@>| !gapinput@sum3 := ClassSumCentralizerNC(rho, class, orth_basis);;|
!gapprompt@gap>| !gapinput@sum1 = sum3;|
true \end{Verbatim}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
