|
################################################################################
##
#W expmulnrnr.gi Near-ring Library J"urgen Ecker
##
## 13.01.00: N!.multiplication ersetzt, PM
#############################################################################
##
#M ExplicitMultiplicationNearRingElementFamilies Initializing method
##
InstallMethod(
ExplicitMultiplicationNearRingElementFamilies,
true,
[IsGroup],
0,
f -> [] );
#############################################################################
##
#F StoreExpMultFam(<fun>,<group>,<fam>) store fam as Exp.Mul.Fam. for fun
## over group
##
StoreExpMultFam := function(fun,group,fam)
local emf;
emf:=ExplicitMultiplicationNearRingElementFamilies(group);
if not ForAny(emf,i->i[1]=fun) then
Add(emf,[fun,fam]);
fi;
end;
#############################################################################
##
#M ExplicitMultiplicationNearRingElementFamily generic method
##
InstallMethod(
ExplicitMultiplicationNearRingElementFamily,
"generic",
true,
[IsGroup,IsFunction],
0,
function(group,fun)
local fam,i;
fam := ExplicitMultiplicationNearRingElementFamilies(Parent(group));
i := PositionProperty(fam,i->i[1]=fun);
if i<>fail then
return fam[i][2];
fi;
fam := NewFamily( "ExplicitMultiplicationNearRingElementFamily(...)",
IsExplicitMultiplicationNearRingElement,
IsObject,
IsExplicitMultiplicationNearRingElementFamily );
# The default kind
fam!.defaultKind := NewType( fam,
IsExplicitMultiplicationNearRingElementDefaultRep);
# Important trivia
fam!.multiplication := fun;
fam!.group := group;
# set one and zero
# SetZero(fam,ObjByExtRep(fam,Zero(f)));;
StoreExpMultFam(fun,group,fam);
return fam;
end);
#############################################################################
##
## IsNearRingMultiplication( <G>, <mul> [, <what>] ). .test if <mul> is a
## nearring multiplication on <G>
##
## This function tests if a specified multiplication function <mul> is a
## nearring multiplication on the group <G>.
##
## <what> is an optional list of properties that the user knows to be true.
## Properties in this are then not checked to speed up the construction
## process. Possible properties are "closed", "ass" and "ldistr"
## If no third argument is given all properties are checked.
IsNearRingMultiplication := function( arg )
local G, mul, elms,
test_closed, test_assoc, test_ldistr;
if Length(arg) = 2 then
test_closed := true;
test_assoc := true;
test_ldistr := true;
G := arg[1];
mul := arg[2];
elif Length(arg) = 3 then
test_closed := not ("closed" in arg[3]);
test_assoc := not ("ass" in arg[3]);
test_ldistr := not ("ldistr" in arg[3]);
G := arg[1];
mul := arg[2];
else
Error("Usage: IsNearRingMultiplication( <G>, <mul> [,{''closed''|''ass''|''ldistr''}] )" );
fi;
if not ( IsGroup( G ) and IsFunction( mul ) ) then
Error("Usage: IsNearRingMultiplication( <G>, <mul> [,{''closed''|''ass''|''ldistr''}] )" );
fi;
elms := Enumerator( G );
if test_closed then
# check if mul is G x G -> G
Info( InfoNearRing, 1, "checking closedness");
if not ForAll( elms, n1 -> ForAll( elms, n2 -> mul( n1, n2 ) in G ) )
then
Info( InfoWarning, 1,
"group is not closed underspecified multiplication" );
return false;
fi;
fi;
if test_assoc then
# check if mul is ASSOCIATIVE
Info( InfoNearRing, 1, "checking associativity");
if not ForAll( elms, n1 -> ForAll( elms, n2 -> ForAll( elms, n3 ->
mul( n1, mul( n2, n3 ) ) = mul( mul( n1, n2 ), n3 ) ) ) )
then
Info( InfoWarning, 1,
"specified multiplication is not associative" );
return false;
fi;
fi;
if test_ldistr then
# check if mul is LEFT DISTRIBUTIVE
# (note that the addition is denoted by '*' )
Info( InfoNearRing, 1, "checking left distributivity");
if not ForAll( elms, n1 -> ForAll( elms, n2 -> ForAll( elms, n3 ->
mul( n1, n2 * n3 ) = mul( n1, n2 ) * mul( n1, n3 ) ) ) )
then
Info( InfoWarning, 1,
"specified multiplication is not left distributive");
return false;
fi;
fi;
# passed all tests
return true;
end;
#############################################################################
##
#M ExplicitMultiplicationNearRing Constructor
##
InstallMethod(
ExplicitMultiplicationNearRing,
"generic",
true,
[IsGroup,IsFunction],
0,
function ( group , mult )
if not IsNearRingMultiplication(group,mult) then
Error("<mult> is not a valid multiplication");
fi;
return ExplicitMultiplicationNearRingNC( group, mult );
end );
#############################################################################
##
#F ExplicitMultiplicationNearRingNC For EMNRs
## multiplication is not tested
InstallGlobalFunction(
ExplicitMultiplicationNearRingNC,
function ( group , mult )
local fam,N;
fam := ExplicitMultiplicationNearRingElementFamily(group,mult);
N := Objectify(
NewType(CollectionsFamily(fam),
IsExplicitMultiplicationNearRing and
IsExplicitMultiplicationNearRingDefaultRep),
rec() );
SetNRMultiplication( N, mult );
N!.elementsInfo := fam;
SetGroupReduct( N, group );
if HasSymbols( group ) then
SetSymbols( N, Symbols( group ) );
fi;
return N;
end );
#############################################################################
##
#M NearRingMultiplicationByOperationTable
##
##
InstallMethod(
NearRingMultiplicationByOperationTable,
"default",
true,
[IsGroup, IsMatrix, IsList],
0,
function( G, OT, elms )
local p, p_inv, mul,
x, y;
p := PermList( List( elms, x -> Position( AsSSortedList( G ), x ) ) );
p_inv := p^-1;
mul := function( x, y )
return AsSSortedList( G )[
( OT [Position( AsSSortedList( G ), x )^p]
[Position( AsSSortedList( G ), y )^p] )
^p_inv ];
end;
return mul;
end );
#############################################################################
##
#M ViewObj For EMNRs
InstallMethod(
ViewObj,
"EMNearRings",
true,
[IsExplicitMultiplicationNearRingDefaultRep],
0,
function ( N )
Print("ExplicitMultiplicationNearRing ( ");
View( GroupReduct(N) );
Print( " , multiplication )");
end );
InstallMethod(
PrintObj,
"EMNearRings",
true,
[IsExplicitMultiplicationNearRingDefaultRep],
0,
function ( N )
Print("ExplicitMultiplicationNearRing ( ");
View( GroupReduct(N) );
Print( " , multiplication )");
end );
#############################################################################
##
#M ExtRepOfObj EMNR element -> group element
InstallMethod(
ExtRepOfObj,
"EMNRDefaultRep->GroupElm",
true,
[IsExplicitMultiplicationNearRingElement and
IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( emnrelm )
return emnrelm![1];
end );
#############################################################################
##
#M NearRingElementByGroupRep Group element -> EMNRDefaultRep
InstallMethod(
NearRingElementByGroupRep,
"EMNRDefaultRep",
true,
[IsExplicitMultiplicationNearRingElementFamily,
IsMultiplicativeElementWithInverse],
0,
function ( fam , grpelm )
local obj;
obj := [grpelm];
Objectify(fam!.defaultKind,obj);
return obj;
end );
#############################################################################
##
#M GroupElementRepOfNearRingElement EMNRDefaultRep -> Group Element
InstallMethod(
GroupElementRepOfNearRingElement,
"EMNRDefaultRep",
true,
[IsExplicitMultiplicationNearRingElement],
0,
function ( elm )
return elm![1];
end );
#############################################################################
##
#M ViewObj For EMNR elements
InstallMethod(
ViewObj,
"EMNRDefaultRep",
true,
[IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( elm )
Print("(",elm![1],")");
end );
InstallMethod(
PrintObj,
"EMNRDefaultRep",
true,
[IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( elm )
Print("(",elm![1],")");
end );
#############################################################################
##
#M \= For EMNR elements
InstallMethod(
\=,
"EMNRElementDefaultRep",
IsIdenticalObj,
[IsExplicitMultiplicationNearRingElementDefaultRep,
IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( a , b )
return a![1] = b![1];
end );
#############################################################################
##
#M \< For EMNR elements
InstallMethod(
\<,
"EMNRElementDefaultRep",
IsIdenticalObj,
[IsExplicitMultiplicationNearRingElementDefaultRep,
IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( a , b )
return a![1] < b![1];
end );
#############################################################################
##
#M \+ For EMNR elements
InstallOtherMethod(
\+,
"EMNRElementsDefaultRep",
IsIdenticalObj,
[IsExplicitMultiplicationNearRingElementDefaultRep,
IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( a , b )
local fam;
fam := FamilyObj(a);
return NearRingElementByGroupRep( fam, a![1]*b![1] );
end );
#############################################################################
##
#M AdditiveInverse For EMNR elements
InstallOtherMethod(
AdditiveInverse,
"EMNRElementDefaultRep",
true,
[IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( a )
return NearRingElementByGroupRep( FamilyObj(a), a![1]^(-1) );
end );
#############################################################################
##
#M Zero For EMNR elements
InstallOtherMethod(
ZeroMutable,
"EMNRElementDefaultRep",
true,
[IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( a )
return NearRingElementByGroupRep( FamilyObj(a), One(a![1]) );
end );
#############################################################################
##
#M \* For EMNR elements
InstallMethod(
\*,
"EMNRElementDefaultRep",
IsIdenticalObj,
[IsExplicitMultiplicationNearRingElementDefaultRep,
IsExplicitMultiplicationNearRingElementDefaultRep],
0,
function ( a , b )
local fam;
fam := FamilyObj(a);
return NearRingElementByGroupRep(
fam, fam!.multiplication(a![1],b![1]) );
end );
##############################################################################
##
#M AsTransformationNearRing( < N > ) for ExplicitMultiplicationNRs
##
InstallMethod(
AsTransformationNearRing,
"for ExpMulNRs",
true,
[IsExplicitMultiplicationNearRing],
0,
function( N )
local nc2, # (N,+) + C_2, the group the tfms act on
C2, # C_2
f, # how it acts
listOfGenerators, # additive generators of the TrfmNR
NR, # the TransformationNearRing
cat, # category of group reduct
mul;
if IsPermGroup( GroupReduct(N) ) then
cat := IsPermGroup;
else
cat := IsPcGroup;
fi;
C2 := CyclicGroup( cat, 2 );
nc2 := DirectProduct( GroupReduct(N), C2 );
if HasName( GroupReduct(N) ) then
SetName( nc2, Concatenation( Name( GroupReduct(N) )," x C_2" ) );
fi;
f := function( n, gamma )
local projNgamma, prod;
projNgamma := Image( Projection(nc2,1), gamma );
if Image( Projection(nc2,2), gamma ) = Identity(C2) then
prod := NRMultiplication(N)( projNgamma, n );
else
prod := n;
fi;
return Image( Embedding(nc2,1), prod );
end;
listOfGenerators := List(
GeneratorsOfGroup( GroupReduct(N) ),
gen -> MappingByFunction( nc2, nc2, x -> f( gen, x ) ) );
NR := TransformationNearRingByAdditiveGenerators( nc2,
listOfGenerators );
return NR;
end );
#############################################################################
##
#M Size For nearrings with known additive group
InstallMethod(
Size,
"nearring with known add group",
true,
[IsTransformationNearRing],
0,
function ( nr )
return Size(GroupReduct(nr));
end );
InstallMethod(
Size,
"nearring with known add group",
true,
[IsExplicitMultiplicationNearRing],
0,
function ( nr )
return Size(GroupReduct(nr));
end );
#############################################################################
##
#M AsList For EMNRs
InstallMethod(
AsList,
"EMNearRings",
true,
[IsNearRing and IsExplicitMultiplicationNearRingDefaultRep],
0,
function ( N )
local addGroup,fam;
addGroup := GroupReduct(N);
fam := N!.elementsInfo;
return List(AsList(addGroup),e->NearRingElementByGroupRep(fam,e));
end );
#############################################################################
##
#M AsSSortedList For EMNRs
InstallMethod(
AsSSortedList,
"EMNearrings",
true,
[IsExplicitMultiplicationNearRingDefaultRep],
0,
function ( N )
local addGroup,fam;
addGroup := GroupReduct(N);
fam := N!.elementsInfo;
return List(AsSSortedList(addGroup),e->NearRingElementByGroupRep(fam,e));
end );
#############################################################################
##
#M Enumerator For ExpMulNRs
InstallMethod(
Enumerator,
true,
[ IsExplicitMultiplicationNearRingDefaultRep ],
0,
function( nr )
return Objectify( NewType( FamilyObj( nr ),
IsList and IsExplicitMultiplicationNearRingEnumerator ),
rec( groupReduct := GroupReduct(nr),
elementsInfo := nr!.elementsInfo ) );
end );
#####################################################################
##
#M Length for nearring enumerators
InstallMethod( Length,
"for enumerator of explicit multiplication nearring",
true,
[ IsList and IsExplicitMultiplicationNearRingEnumerator ],
0,
e -> Size( e!.groupReduct ) );
#####################################################################
##
#M \[\] for nearring enumerators
InstallMethod(
\[\],
true,
[ IsList and IsExplicitMultiplicationNearRingEnumerator, IsPosInt ],
0,
function( e, pos )
local groupElement, group, fam;
group := e!.groupReduct;
fam := e!.elementsInfo;
groupElement := Enumerator(group)[pos];
return NearRingElementByGroupRep( fam, groupElement );
end );
#####################################################################
##
#M Position for nearring enumerators
InstallMethod(
Position,
true,
[ IsList and IsExplicitMultiplicationNearRingEnumerator,
IsExplicitMultiplicationNearRingElementDefaultRep, IsZeroCyc ],
0,
function( e, emnrelm, zero )
return Position(Enumerator(e!.groupReduct),emnrelm![1],zero);
end );
#####################################################################
##
#M ViewObj for nearring enumerators
#
InstallMethod(
ViewObj,
true,
[ IsExplicitMultiplicationNearRingEnumerator ],
0,
function( G )
Print( "<enumerator of near ring>" );
end );
#############################################################################
##
#M SubNearRingBySubgroupNC
##
## No Check!
InstallMethod(
SubNearRingBySubgroupNC,
"ExpMultNRs",
true,
[IsExplicitMultiplicationNearRing, IsGroup],
0,
function ( nr, sg )
local fam, subnr;
fam := nr!.elementsInfo;
subnr := Objectify(
NewType(CollectionsFamily(fam),
IsExplicitMultiplicationNearRing and
IsExplicitMultiplicationNearRingDefaultRep),
rec() );
SetNRMultiplication( subnr, NRMultiplication( nr ) );
subnr!.elementsInfo := fam;
SetGroupReduct( subnr, sg );
SetParent( subnr, nr );
return subnr;
end );
#############################################################################
##
#M InvariantSubNearRings
##
InstallMethod(
InvariantSubNearRings,
"ExpMultNRs",
true,
[IsNearRing and IsExplicitMultiplicationNearRing],
0,
function( N )
local mul, sgps, g, m, invars, isinv, i;
mul := NRMultiplication(N);
sgps := Subgroups( GroupReduct(N) );
invars := [];
for g in sgps do
isinv := true;
i := 0;
while i < Size(g) and isinv do
i := i+1;
m := Enumerator(g)[i];
if ForAny( N, n -> not ( mul( m, GroupElementRepOfNearRingElement(n) ) in g ) or
not ( mul( GroupElementRepOfNearRingElement(n), m ) in g ) ) then
isinv := false;
fi;
od;
if isinv then Add( invars, g ); fi;
od;
return List( invars, inv -> SubNearRingBySubgroupNC( N, inv ) );
end );
#############################################################################
##
#M SubNearRings for ExpMulNRs
##
InstallMethod(
SubNearRings,
"ExpMultNRs",
true,
[IsNearRing and IsExplicitMultiplicationNearRing],
0,
function( N )
local mul, sgps, subnrs;
mul := NRMultiplication(N);
sgps := Subgroups( GroupReduct(N) );
subnrs := Filtered( sgps,
g -> ForAll( g, m -> ForAll( g, n -> mul(m,n) in g ) ) );
return List( subnrs, sg -> SubNearRingBySubgroupNC( N, sg ) );
end );
#############################################################################
##
#M ZeroSymmetricPart for ExpMulNRs
##
InstallMethod(
ZeroSymmetricPart,
"ExpMulNRs",
true,
[IsNearRing and IsExplicitMultiplicationNearRing],
0,
function ( N )
local addGroup, zero, sg, n;
addGroup := GroupReduct( N );
zero := Identity( addGroup );
sg := TrivialSubgroup( addGroup );
for n in addGroup do
if not ( n in sg ) and NRMultiplication(N)( zero, n ) = zero then
sg := ClosureSubgroup( sg, n );
fi;
od;
return SubNearRingBySubgroupNC( N, sg );
end );
[ Dauer der Verarbeitung: 0.31 Sekunden
(vorverarbeitet)
]
|
