diff --git a/doc/cartan.xml b/doc/cartan.xml
index 013962c25..22eddc9ec 100644
--- a/doc/cartan.xml
+++ b/doc/cartan.xml
@@ -31,14 +31,6 @@
semigroup S. In a group generalized conjugacy classes coincide
with conjugacy classes.
- Note that each generalized conjugacy class as currently implemented
- does not store a list of elements in the conjugacy class, only the representative
- with no way to compute all the elements in the conjugacy class.
- This means that
- as currently
- implemented is only as effective as
- .
-
S := FullTransformationMonoid(6);;
gap> GeneralizedConjugacyClassesRepresentatives(S);
@@ -185,13 +177,13 @@ gap> BlockDiagonalMatrixOfCharacterTables(S);
<#/GAPDoc>
-<#GAPDoc Label="MonoidCharacterTable">
+<#GAPDoc Label="CharacterTable">
-
+ The character table object for M over F.
Called with a finite monoid M and optionally a field F,
- returns the character table of the
+ returns the character table of the
monoid which is defined as the matrix Trace(X(m)), where X
runs over the simple FM-modules and m runs over the
generalized conjugacy class representatives of M.
@@ -201,7 +193,7 @@ gap> BlockDiagonalMatrixOfCharacterTables(S);
.
If F is not given, then
- returns the character table of
+ returns the character table of
M over a characteristic zero splitting field of M.
At the moment, methods are available for the following cases:
@@ -212,7 +204,7 @@ gap> BlockDiagonalMatrixOfCharacterTables(S);
S := FullTransformationMonoid(3);;
-gap> ct := MonoidCharacterTable(S);;
+gap> ct := CharacterTable(S);;
gap> Irr(ct);;
gap> Display(ct);
c.1 c.2 c.3 c.4 c.5 c.6
@@ -242,7 +234,7 @@ X.6 1 1 1 1 1 1
the presentation of the monoid display inconsistently -->
M := FullBooleanMatMonoid(2);;
-gap> ct := MonoidCharacterTable(M);;
+gap> ct := CharacterTable(M);;
gap> Irr(ct);
[ MonoidCharacter( MonoidCharacterTable( Monoid( [ Matrix(IsBooleanMat\
, [ [ false, true ], [ true, false ] ]), Matrix(IsBooleanMat, [ [ true\
@@ -268,23 +260,23 @@ gap> Irr(ct);
<#/GAPDoc>
-<#GAPDoc Label="MonoidCartanMatrix">
+<#GAPDoc Label="CartanMatrix">
-
+ An object.
Called with a finite monoid M and a field F,
- returns the Cartan matrix of the monoid
+ returns the Cartan matrix of the monoid
algebra FM which is defined as the matrix
dim Hom(P,Q)/dim End(P / rad(FM)), where P and Q
run over the right indecomposable projective modules of FM.
To get the Cartan matrix of a monoid to display like the example below,
the projective indecomposable modules need to be computed first using
- .
+ .
If M is the only argument then
- returns the Cartan matrix of the monoid
+ returns the Cartan matrix of the monoid
algebra FM, where F is a splitting field of M over
the rationals.
@@ -296,7 +288,7 @@ gap> Irr(ct);
S := FullTransformationMonoid(3);;
-gap> cm := MonoidCartanMatrix(S);;
+gap> cm := CartanMatrix(S);;
gap> Pims(cm);;
gap> Display(cm);
X.1 X.2 X.3 X.4 X.5 X.6
@@ -315,10 +307,10 @@ P.6 . . . 1 . 1
<#GAPDoc Label="Pims">
+ Label = "for a cartan matrix"/>
A list of monoid characters.
- returns a
+ returns a
list of the characters of the projective indecomposable
modules of the monoid of the monoid character table T.
@@ -326,7 +318,7 @@ P.6 . . . 1 . 1
the presentation of the monoid display inconsistently -->
M := FullBooleanMatMonoid(2);;
-gap> cm := MonoidCartanMatrix(M);;
+gap> cm := CartanMatrix(M);;
gap> Pims(cm);
[ MonoidCharacter( MonoidCharacterTable( Monoid( [ Matrix(IsBooleanMat\
, [ [ false, true ], [ true, false ] ]), Matrix(IsBooleanMat, [ [ true\
diff --git a/gap/attributes/cartan.gd b/gap/attributes/cartan.gd
index 7bce38369..09a5e1e97 100644
--- a/gap/attributes/cartan.gd
+++ b/gap/attributes/cartan.gd
@@ -9,23 +9,29 @@
#############################################################################
##
-DeclareCategory("IsGeneralizedConjugacyClass", IsObject);
+DeclareCategory("IsGeneralizedConjugacyClass", IsCollection);
DeclareAttribute("Representative", IsGeneralizedConjugacyClass);
DeclareAttribute("ParentAttr", IsGeneralizedConjugacyClass);
+DeclareAttribute("MapToGroupHClass", IsGeneralizedConjugacyClass);
DeclareOperation("GeneralizedConjugacyClass",
[IsSemigroup, IsMultiplicativeElement]);
-DeclareAttribute("GeneralizedConjugacyClassesRepresentatives", IsSemigroup);
+DeclareOperation("GeneralizedConjugacyClass",
+ [IsSemigroup, IsMultiplicativeElement, IsGeneralMapping]);
DeclareAttribute("GeneralizedConjugacyClasses", IsSemigroup);
+DeclareAttribute("GeneralizedConjugacyClassesRepresentatives", IsSemigroup);
DeclareCategory("IsMonoidCharacterTable", IsObject);
DeclareAttribute("ParentAttr", IsMonoidCharacterTable);
-DeclareAttribute("MonoidCharacterTable", IsSemigroup);
+DeclareAttribute("CartanMatrix", IsMonoidCharacterTable);
+DeclareAttribute("OrdinaryCharacterTable", IsSemigroup);
+DeclareOperation("CharacterTable", [IsSemigroup]);
DeclareCategory("IsMonoidCharacter", IsObject);
-DeclareOperation("MonoidCharacter", [IsMonoidCharacterTable, IsList]);
-DeclareOperation("PimMonoidCharacter",
+DeclareOperation("Character", [IsMonoidCharacterTable, IsList]);
+DeclareOperation("Character",
[IsMonoidCharacterTable, IsDenseList, IsMonoidCharacter]);
+DeclareOperation("\^", [IsMultiplicativeElement, IsMonoidCharacter]);
DeclareAttribute("ParentAttr", IsMonoidCharacter);
-DeclareAttribute("ValuesOfMonoidClassFunction", IsMonoidCharacter);
+DeclareAttribute("ValuesOfClassFunction", IsMonoidCharacter);
DeclareAttribute("ProjectiveCoverOf", IsMonoidCharacter);
DeclareAttribute("ValuesOfCompositionFactorsFunction", IsMonoidCharacter);
DeclareAttribute("DClassBicharacter", IsGreensDClass);
@@ -38,6 +44,6 @@ DeclareAttribute("Irr", IsMonoidCharacterTable);
DeclareCategory("IsMonoidCartanMatrix", IsObject);
DeclareAttribute("ParentAttr", IsMonoidCartanMatrix);
-DeclareAttribute("MonoidCartanMatrix", IsSemigroup);
+DeclareAttribute("CartanMatrix", IsSemigroup);
DeclareAttribute("Pims", IsMonoidCartanMatrix);
\ No newline at end of file
diff --git a/gap/attributes/cartan.gi b/gap/attributes/cartan.gi
index ed932176c..2d2ca6feb 100644
--- a/gap/attributes/cartan.gi
+++ b/gap/attributes/cartan.gi
@@ -14,19 +14,42 @@
# This object is to be a placeholder to eventually hold all the elements
# which are in the same generalized conjugacy class. This will then allow
# the monoid characters to work like characters in the case of groups.
-BindGlobal("GeneralizedConjugacyClassType",
-NewType(NewFamily("GeneralizedConjugacyClassFamily"),
- IsGeneralizedConjugacyClass and
- IsAttributeStoringRep));
-
InstallMethod(GeneralizedConjugacyClass,
"for a semigroup and a multiplicative element",
[IsSemigroup, IsMultiplicativeElement],
function(S, s)
- local result;
- result := Objectify(GeneralizedConjugacyClassType, rec());
+ local result, fam;
+
+ fam := FamilyObj(S);
+
+ if not IsBound(fam!.defaultGenerlaizedClassType) then
+ fam!.defaultGenerlaizedClassType := NewType(fam,
+ IsGeneralizedConjugacyClass and IsAttributeStoringRep);
+ fi;
+
+ result := Objectify(fam!.defaultGenerlaizedClassType, rec());
+ SetRepresentative(result, s);
+ SetParentAttr(result, S);
+ return result;
+end);
+
+InstallMethod(GeneralizedConjugacyClass,
+ "for a semigroup and a multiplicative element",
+[IsSemigroup, IsMultiplicativeElement, IsGeneralMapping],
+function(S, s, map)
+ local result, fam;
+
+ fam := FamilyObj(S);
+
+ if not IsBound(fam!.defaultGenerlaizedClassType) then
+ fam!.defaultGenerlaizedClassType := NewType(fam,
+ IsGeneralizedConjugacyClass and IsAttributeStoringRep);
+ fi;
+
+ result := Objectify(fam!.defaultGenerlaizedClassType, rec());
SetRepresentative(result, s);
SetParentAttr(result, S);
+ SetMapToGroupHClass(result, map);
return result;
end);
@@ -39,11 +62,23 @@ function(generalizedconjugacyclass)
Representative(generalizedconjugacyclass));
end);
+InstallMethod(\=, "for generalized conjugacy classes",
+[IsGeneralizedConjugacyClass, IsGeneralizedConjugacyClass],
+function(gcc1, gcc2)
+ if ParentAttr(gcc1) <> ParentAttr(gcc2) then
+ return false;
+ fi;
+ if Representative(gcc1) = Representative(gcc2) then
+ return true;
+ fi;
+ return Representative(gcc1) in AsList(gcc2);
+end);
+
InstallMethod(DisplayString, "for a generalized conjugacy class",
[IsGeneralizedConjugacyClass],
ViewString);
-InstallMethod(GeneralizedConjugacyClassesRepresentatives, "for a semigroup",
+InstallMethod(GeneralizedConjugacyClasses, "for a semigroup",
[IsSemigroup],
function(S)
local D, out, C, map, invmap;
@@ -57,26 +92,89 @@ function(S)
# Ugly fix: ensures that the conjugacy classes are computed
# in the same order each time.
invmap := InverseGeneralMapping(map);
- C := List(C, x -> x ^ invmap);
+ C := List(C, x -> GeneralizedConjugacyClass(S, x ^ invmap, map));
Append(out, C);
od;
return out;
end);
-InstallMethod(GeneralizedConjugacyClasses, "for a semigroup",
+InstallMethod(GeneralizedConjugacyClassesRepresentatives, "for a semigroup",
[IsSemigroup],
-function(S)
- return List(GeneralizedConjugacyClassesRepresentatives(S),
- x -> GeneralizedConjugacyClass(S, x));
+S -> List(GeneralizedConjugacyClasses(S), Representative));
+
+InstallMethod(AsList, "for a generalized conjugacy class",
+[IsGeneralizedConjugacyClass],
+function(gcc)
+ local S, rclasses, allgcc, repgcc, holderoflists, s, w, sw, temprclass,
+ Rsw, tempgcc, e, Le, RtoLse, LtoHes, i;
+
+ S := ParentAttr(gcc);
+ rclasses := RClasses(S);
+ allgcc := GeneralizedConjugacyClasses(S);
+ repgcc := GeneralizedConjugacyClassesRepresentatives(S);
+
+ if not HasAsList(allgcc[1]) then
+ holderoflists := List(allgcc, x -> []);
+ for s in S do
+ w := SmallestIdempotentPower(s);
+ sw := s ^ w;
+ for temprclass in rclasses do
+ if sw in temprclass then
+ Rsw := temprclass;
+ break;
+ fi;
+ od;
+ for tempgcc in allgcc do
+ if not sw in DClassOfHClass(Source(MapToGroupHClass(tempgcc))) then
+ continue;
+ fi;
+ e := MultiplicativeNeutralElement(Source(MapToGroupHClass(tempgcc)));
+ Le := LClassOfHClass(Source(MapToGroupHClass(tempgcc)));
+ RtoLse := Intersection(Rsw, Le)[1];
+ LtoHes := LeftGreensMultiplier(S, RtoLse, e);
+ if IsConjugate(Image(MapToGroupHClass(tempgcc)),
+ MapToGroupHClass(tempgcc)(LtoHes * sw * s * RtoLse),
+ MapToGroupHClass(tempgcc)(Representative(tempgcc))) then
+ Add(holderoflists[Position(repgcc, Representative(tempgcc))], s);
+ break;
+ fi;
+ od;
+ od;
+ for i in [1 .. Length(allgcc)] do
+ SetAsList(allgcc[i], holderoflists[i]);
+ od;
+ fi;
+
+ for tempgcc in allgcc do
+ if Representative(gcc) in AsList(tempgcc) then
+ return AsList(tempgcc);
+ fi;
+ od;
+
+ return fail;
end);
+InstallMethod(Enumerator, "for a generalized conjugacy class",
+[IsGeneralizedConjugacyClass],
+gcc -> Enumerator(AsList(gcc)));
+
+# This method is not run
+# The test has been updated to show that this method would work if it were run
+InstallMethod(\in, "for a object and a generalized conjugacy class",
+[IsObject, IsGeneralizedConjugacyClass],
+{obj, gcc} -> obj in AsList(gcc));
+
BindGlobal("MonoidCharacterTableType",
NewType(NewFamily("MonoidCharacterTableFamily"),
IsMonoidCharacterTable and
IsAttributeStoringRep));
-InstallMethod(MonoidCharacterTable, "for a semigroup",
+InstallMethod(CharacterTable, "for a semigroup",
+[IsMonoidAsSemigroup],
+OrdinaryCharacterTable);
+
+InstallMethod(OrdinaryCharacterTable, "for a semigroup",
[IsMonoidAsSemigroup],
function(S)
local result;
@@ -119,9 +217,9 @@ function(ct)
sizetable := Length(Irr(ct));
strarray := List([1 .. sizetable], x -> List([1 .. sizetable], y -> "."));
- ctmatrix := List(Irr(ct), ValuesOfMonoidClassFunction);
+ ctmatrix := List(Irr(ct), ValuesOfClassFunction);
rosetastone := Filtered(Unique(Concatenation(List(Irr(ct),
- ValuesOfMonoidClassFunction))),
+ ValuesOfClassFunction))),
x -> not IsInt(x));
columnlabels := List([1 .. 2], x -> List([1 .. sizetable], y -> " "));
@@ -209,37 +307,41 @@ function(ct)
return str;
end);
-BindGlobal("MonoidCartanMatrixType",
-NewType(NewFamily("MonoidCartanMatrixFamily"),
+BindGlobal("CartanMatrixType",
+NewType(NewFamily("CartanMatrixFamily"),
IsMonoidCartanMatrix and
IsAttributeStoringRep));
-InstallMethod(MonoidCartanMatrix, "for a semigroup",
+InstallMethod(CartanMatrix, "for a semigroup",
[IsMonoidAsSemigroup],
-function(S)
+S -> CartanMatrix(CharacterTable(S)));
+
+InstallMethod(CartanMatrix, "for a monoid character table",
+[IsMonoidCharacterTable],
+function(ct)
local result;
- result := Objectify(MonoidCartanMatrixType, rec());
- SetParentAttr(result, S);
+ result := Objectify(CartanMatrixType, rec());
+ SetParentAttr(result, ct);
return result;
end);
-InstallMethod(ViewString, "for a monoid cartan matrix",
+InstallMethod(ViewString, "for a cartan matrix",
[IsMonoidCartanMatrix],
function(cm)
- return StringFormatted("MonoidCartanMatrix( {} )",
+ return StringFormatted("CartanMatrix( {} )",
ParentAttr(cm));
end);
-InstallMethod(DisplayString, "for a monoid cartan matrix",
+InstallMethod(DisplayString, "for a cartan matrix",
[IsMonoidCartanMatrix],
function(cm)
local str, columnlabels, rowlabels, strarray, sizetable, i, j, cmmatrix,
coltable, columnwidth, rowlabelwidth, currentwidth, currentpage,
screensizeassume, quotientcolumnwidthsums, temp, temp2;
- str := StringFormatted("MonoidCartanMatrix( {} )",
+ str := StringFormatted("CartanMatrix( {} )",
ParentAttr(cm));
if HasPims(cm) then
@@ -326,14 +428,14 @@ NewType(NewFamily("MonoidCharacterFamily"),
IsMonoidCharacter and
IsAttributeStoringRep));
-InstallMethod(MonoidCharacter, "for a monoid character table and dense list",
+InstallMethod(Character, "for a monoid character table and dense list",
[IsMonoidCharacterTable, IsDenseList],
function(ct, values)
local result;
result := Objectify(MonoidCharacterType, rec());
SetParentAttr(result, ct);
- SetValuesOfMonoidClassFunction(result, values);
+ SetValuesOfClassFunction(result, values);
return result;
end);
@@ -342,10 +444,10 @@ InstallMethod(ViewString, "for a monoid character",
[IsMonoidCharacter],
function(char)
local str;
- if HasValuesOfMonoidClassFunction(char) then
+ if HasValuesOfClassFunction(char) then
str := StringFormatted("MonoidCharacter( {} , {} )",
ViewString(ParentAttr(char)),
- ValuesOfMonoidClassFunction(char));
+ ValuesOfClassFunction(char));
elif HasProjectiveCoverOf(char) then
str := StringFormatted("MonoidCharacter( {} , Projective Cover Of {} )",
ViewString(ParentAttr(char)),
@@ -355,6 +457,45 @@ function(char)
return str;
end);
+InstallMethod(ValuesOfClassFunction, "for a monoid character",
+[IsMonoidCharacter],
+function(char)
+ local ct;
+ if HasValuesOfCompositionFactorsFunction(char) then
+ ct := List(Irr(ParentAttr(char)), ValuesOfClassFunction);
+ return ValuesOfCompositionFactorsFunction(char) * ct;
+ fi;
+
+ Error("No method to generate ValuesOfClassFunction in this case");
+end);
+
+InstallOtherMethod(\^, "for a multiplicative element and a monoid character",
+[IsMultiplicativeElement, IsMonoidCharacter],
+function(obj, char)
+ local ct, M, values, gcc, i;
+
+ ct := ParentAttr(char);
+ M := ParentAttr(ct);
+ values := ValuesOfClassFunction(char);
+ gcc := GeneralizedConjugacyClasses(M);
+
+ if obj = Identity(M) then
+ for i in [1 .. Size(gcc)] do
+ if Identity(M) = Representative(gcc[i]) then
+ return values[i];
+ fi;
+ od;
+ fi;
+
+ for i in [1 .. Size(gcc)] do
+ if obj in gcc[i] then
+ return values[i];
+ fi;
+ od;
+
+ Error("The object is not in the semigroup.");
+end);
+
InstallMethod(DClassBicharacter, "for a D-class",
[IsGreensDClass],
function(D)
@@ -667,10 +808,10 @@ function(ct)
Rrad := Concatenation(List(transversalHclasses,
RClassRadicalBicharacterOfGroupHClass));
irrvalues := Inverse(TransposedMat(D)) * (R - Rrad);
- return List(irrvalues, x -> MonoidCharacter(ct, x));
+ return List(irrvalues, x -> Character(ct, x));
end);
-InstallMethod(PimMonoidCharacter,
+InstallMethod(Character,
"for a monoid character table, dense list, and monoid character",
[IsMonoidCharacterTable, IsDenseList, IsMonoidCharacter],
function(ct, values, char)
@@ -684,17 +825,17 @@ function(ct, values, char)
return result;
end);
-InstallMethod(Pims, "for a monoid Cartan matrix",
+InstallMethod(Pims, "for a cartan matrix",
[IsMonoidCartanMatrix],
function(cm)
local C, S, ct, M, out;
- S := ParentAttr(cm);
- ct := MonoidCharacterTable(S);
- C := List(Irr(ct), ValuesOfMonoidClassFunction);
- M := RegularRepresentationBicharacter(S);
+ ct := ParentAttr(cm);
+ S := ParentAttr(ct);
+ C := List(Irr(ct), ValuesOfClassFunction);
+ M := RegularRepresentationBicharacter(S);
out := Inverse(TransposedMatMutable(C)) * M * Inverse(C);
return List([1 .. Length(out)],
- n -> PimMonoidCharacter(ct, out[n], Irr(ct)[n]));
+ n -> Character(ct, out[n], Irr(ct)[n]));
end);
diff --git a/tst/standard/attributes/cartan.tst b/tst/standard/attributes/cartan.tst
index b577a6712..fda23a37b 100644
--- a/tst/standard/attributes/cartan.tst
+++ b/tst/standard/attributes/cartan.tst
@@ -18,7 +18,7 @@ gap> SEMIGROUPS.StartTest();
# Creation of a lazy monoid character table - 1
gap> S := FullTransformationMonoid(3);;
-gap> MonoidCharacterTable(S);
+gap> CharacterTable(S);
MonoidCharacterTable( Monoid( [ Transformation( [ 2, 3, 1 ] ), Transformation(\
[ 2, 1 ] ), Transformation( [ 1, 2, 1 ] ) ] ) )
@@ -39,11 +39,50 @@ gap> GeneralizedConjugacyClass(M, m);
formation( [ 2, 1 ] ), Transformation( [ 1, 2, 1 ] ) ] ) for representative Tr\
ansformation( [ 3, 2, 2 ] )>
+# AsList GeneralizedConjugacyClass test
+gap> M := FullTransformationMonoid(3);;
+gap> m := Transformation([3, 2, 2]);;
+gap> AsList(GeneralizedConjugacyClass(M, m));
+[ Transformation( [ 1, 1, 1 ] ), Transformation( [ 1, 1, 2 ] ),
+ Transformation( [ 1, 3, 1 ] ), Transformation( [ 2, 2, 1 ] ),
+ Transformation( [ 2, 2, 2 ] ), Transformation( [ 2, 3, 3 ] ),
+ Transformation( [ 3, 1, 3 ] ), Transformation( [ 3, 2, 2 ] ),
+ Transformation( [ 3, 3, 3 ] ) ]
+
+# AsList GeneralizedConjugacyClass test
+gap> M := FullTransformationMonoid(3);;
+gap> m := Transformation([2, 2, 1]);;
+gap> Size(GeneralizedConjugacyClass(M, m));
+9
+
+# \in GeneralizedConjugacyClass test
+gap> M := FullTransformationMonoid(3);;
+gap> m := Transformation([2, 2, 1]);;
+gap> ccm := GeneralizedConjugacyClasses(M);;
+gap> Size(ccm);
+6
+gap> Number(ccm, c -> m in c);
+1
+
+# Projective Character finde ValuesOfClassFunction test
+gap> M := FullTransformationMonoid(3);;
+gap> cm := CartanMatrix(M);;
+gap> pims := Pims(cm);;
+gap> mat := List(pims, ValuesOfClassFunction);;
+gap> known := [[1, -1, 1, 0, 0, 0],
+> [2, 0, -1, 0, 0, 0],
+> [4, 0, 1, 1, -1, 0],
+> [3, -1, 0, 1, -1, 0],
+> [3, 1, 0, 1, 1, 0],
+> [3, 1, 0, 2, 0, 1]];;
+gap> TransformingPermutations(mat, known) <> fail;
+true
+
# Simple check of a monoid character table - 1
gap> S := FullTransformationMonoid(3);;
-gap> ct := MonoidCharacterTable(S);;
+gap> ct := CharacterTable(S);;
gap> irr := Irr(ct);;
-gap> mat := List(irr, ValuesOfMonoidClassFunction);;
+gap> mat := List(irr, ValuesOfClassFunction);;
gap> known := [[1, -1, 1, 0, 0, 0],
> [2, 0, -1, 0, 0, 0],
> [1, 1, 1, 0, 0, 0],
@@ -53,12 +92,33 @@ gap> known := [[1, -1, 1, 0, 0, 0],
gap> TransformingPermutations(mat, known) <> fail;
true
-# Check display string of MonoidCharacterTable - 1
-# Explicitly enable acting methods because the order of the D-classes
-# is not canonical and a permutation on the D-classes may be lead to
-# a different display string.
+# Check application of monoid character to an element - 1
+gap> M := FullTransformationMonoid(3);;
+gap> ct := CharacterTable(M);;
+gap> m := Transformation([2, 2, 1]);;
+gap> Number(List(Irr(ct), chi -> m ^ chi), x -> x = 1);
+1
+gap> Number(List(Irr(ct), chi -> m ^ chi), x -> x = 0);
+5
+
+# Check special use of MyExp for the identity element - 1
+gap> M := FullTransformationMonoid(3);;
+gap> ct := CharacterTable(M);;
+gap> m := Identity(M);;
+gap> mat := List(Irr(ct), chi -> m ^ chi);;
+gap> known := [1, 2, 1, 2, 3, 1];;
+gap> TransformingPermutations([mat], [known]) <> fail;
+true
+gap> ccm := GeneralizedConjugacyClasses(M);;
+gap> HasAsList(ccm[1]);
+false
+
+# Check display string of MonoidCharacterTable - 1
+# Explicitly enable acting methods because the order of the D-classes
+# is not canonical and a permutation on the D-classes may be lead to
+# a different display string.
gap> S := Monoid(FullTransformationMonoid(3), rec(acting := true));;
-gap> ct := MonoidCharacterTable(S);;
+gap> ct := CharacterTable(S);;
gap> Irr(ct);;
gap> Display(ct);
c.1 c.2 c.3 c.4 c.5 c.6
@@ -71,15 +131,14 @@ X.5 3 1 . 1 1 .
X.6 1 1 1 1 1 1
-# Creation of a lazy monoid cartan matrix - 1
+# Creation of a lazy cartan matrix - 1
gap> S := FullTransformationMonoid(3);;
-gap> MonoidCartanMatrix(S);
-MonoidCartanMatrix( Monoid( [ Transformation( [ 2, 3, 1 ] ), Transformation( [\
- 2, 1 ] ), Transformation( [ 1, 2, 1 ] ) ] ) )
+gap> CartanMatrix(S);
+CartanMatrix(