SSL grptfms.gi Sprache: unbekannt

################################################################################
##
#W  grptfms.gi             Near-ring Library                   Christof N"obauer
##
#Y  Copyright (C)
##
##  $Log: grptfms.gi,v $
##  Revision 1.15  2015/04/09 13:43:54  stein
##  Added condition to make the method "abelian near ring (Binder e.a.)" for IsDistributiveNearring only applicable to abelian nearrings.
##
##  Revision 1.14  2012-11-07 13:22:59  stein
##  Adapted filters in method for \in.
##
##  Revision 1.13  2011-11-23 20:01:17  stein
##  New methods for Zero for elements of a nearring.
##  New methods for multiplying a nearring element with an integer (These should
##  be integrated into GAP in a future release and then removed from nr.gi).
##
##  Revision 1.12  2011-06-17 08:48:13  stein
##  changed order of methods for GroupElementRepOfNearRingElement
##
##  Revision 1.11  2008-11-13 14:17:16  stein
##  Restricted the Enumerator - Method to IsTransformationNearRing
##  Replaced IsNearRingEnumerator by IsTransformationNearRingEnumerator
##
##  Revision 1.10  2007/07/19 22:40:33  stein
##  removed reference to IsNearRingWithOne
##
##  Revision 1.9  2007/05/09 21:26:16  stein
##  put the full TransformationNearRing into IsNearRingWithOne
##
##  Revision 1.8  2004/02/26 16:22:43  juergen
##  new filter for Random method
##
##  Revision 1.7  2003/03/07 13:48:20  juergen
##  new method for IsDistributiveNearRing
##
##  Revision 1.6  2002/01/18 07:20:30  erhard
##  I have added the function GraphOfMapping.
##
##  Revision 1.5  2001/06/28 18:57:08  erhard
##  I have added the functions EndoMappingByFunction, AsEndoMapping,
##  IdentityEndoMapping, IsIdentityEndoMapping, IsDistributiveEndoMapping.
##
##  Revision 1.4  2001/03/21 16:22:09  juergen
##  noch ein paar filter angepasst
##
##  Revision 1.2  2001/03/21 14:41:07  juergen
##  erste korrekturen nach dem studium des tutorials
##
##  Revision 1.1.1.1  2000/02/21 15:59:03  hetzi
##  Sonata Project Start
##

#############################################################################
##
#F  SizeFoldDirectProduct ( <G> ) ...  returns the direct
##   product G^|G| for the group G.
##

InstallMethod(
SizeFoldDirectProduct,
"of a group",
true,
[IsGroup],
0,
  G -> DirectProduct( List ([1..Size (G)], i -> G) )
);

###############################################################################
##
#M  \+
##

InstallOtherMethod(\+, "for IsTransformationRepOfEndo", IsIdenticalObj,
  [IsTransformationRepOfEndo and IsEndoGeneralMapping,
  IsTransformationRepOfEndo and IsEndoGeneralMapping], 0,
function(m, n)
  local mntrans, en;

  if Source(n) <> Source(m) then
    TryNextMethod();
  fi;

  en := EnumeratorSorted(Source(m));
  mntrans := Transformation(List([1 .. Length(en)],
    i->Position(en, en[i^m!.transformation] * en[i^n!.transformation])));

  return EndoMappingByTransformation(Source(m),FamilyObj(m), mntrans);
end);

InstallOtherMethod(\+, "for IsEndoGeneralMapping", IsIdenticalObj,
  [IsGeneralMapping, IsGeneralMapping], 0,
function(m, n)

  if Source(n) <> Source(m) then
    TryNextMethod();
  fi;

  return MappingByFunction(Source(m),Source(m), g->(g^m)*(g^n));
end);

#############################################################################
##
#M  Zero For NR elements
##

InstallOtherMethod(
ZeroMutable,
"for IsTransformationRepOfEndo",
true,
[IsTransformationRepOfEndo and IsEndoGeneralMapping],
0,
  function ( m )
  local en, o, mntrans;

  en := EnumeratorSorted(Source(m));
  o := Position( en, en[1]^0 );
  mntrans := Transformation(List([1 .. Length(en)], i-> o) );

  return EndoMappingByTransformation(Source(m),FamilyObj(m), mntrans);
end );

## the following conflicts with GAP's method Zero for homomorphisms
#InstallOtherMethod(
# ZeroMutable,
# "for IsEndoGeneralMapping",
# true,
# [IsGeneralMapping], 0,
#  function(m)
#  local en, o;
#
#    en := Source(m);
#    o := Identity( en );
#
#    return MappingByFunction(Source(m),Source(m), g-> o );
#  end );

###############################################################################
##
#M  AdditiveInverse
##

InstallOtherMethod(
AdditiveInverseOp,
"for IsTransformationRepOfEndo",
true,
   [IsTransformationRepOfEndo and IsEndoGeneralMapping],
0,
  function(m)
  local en, mntrans;

  en := EnumeratorSorted(Source(m));
  mntrans := Transformation(List([1 .. Length(en)],
    i->Position(en, en[i^m!.transformation]^(-1))));

  return EndoMappingByTransformation(Source(m),FamilyObj(m), mntrans);
end);

InstallOtherMethod(
AdditiveInverseOp,
"for IsEndoGeneralMapping",
true,
[IsGeneralMapping], 0,
  function(m)
    return MappingByFunction(Source(m),Source(m), g->(g^m)^(-1));
  end );

#############################################################################
##
#M  NearRingElementByGroupRep

InstallMethod(
NearRingElementByGroupRep,
"Group element -> vector",
true,
[IsGroup,IsMultiplicativeElementWithInverse],
0,
  function ( G , dpElement )
    return GroupGeneralMappingByGroupElement( G, dpElement );
  end );

InstallMethod(
EndoMappingFamily,
"stupid",
true,
[IsGroup],
0,
  G -> FamilyObj( TransformationRepresentation( IdentityMapping( G ) ) )
  );

InstallMethod(
GroupGeneralMappingByGroupElement,
"Group element -> mapping",
true,
[IsGroup,IsMultiplicativeElementWithInverse],
0,
  function( G, g )
  local DP, elms, trafo, m, fam;
    DP := SizeFoldDirectProduct( G );
    fam := EndoMappingFamily( G );
    elms := EnumeratorSorted(G);
    trafo := TransformationNC(
List( [1..Length (DirectProductInfo(DP).groups)],
             i -> Position( elms, FastImageOfProjection( DP, g, i ) )
     ) );
    m := EndoMappingByTransformation( G, fam, trafo );
    SetGroupElementRepOfNearRingElement( m, g );

    return m;
  end );

#############################################################################
##
#M  GroupElementRepOfNearRingElement

InstallMethod(
GroupElementRepOfNearRingElement,
"mapping -> group element",
true,
[IsMapping],
0,
  function ( t )

  local dpElement,    # the element of the direct product to be returned
DP,       # a direct product of groups
elms,       # elements of the group the transformation acts on
vec;       # the transformation as a vector

    DP := SizeFoldDirectProduct( Source( t ) );
    elms := AsSSortedList( Source( t ) );
    dpElement := Identity( DP );
    vec := List( elms, x -> Position( elms, ImageElm( t, x ) ) );

    dpElement := Product( [1..Length(vec)],
   i -> Image (Embedding (DP, i), elms[ vec[i] ])
   );

    return dpElement;
  end );

InstallMethod(
GroupElementRepOfNearRingElement,
"GroupGeneralMappingTrafoRep -> group element",
true,
[IsGroupGeneralMapping and IsTransformationRepOfEndo],
0,
  function ( t )

  local fam,       # family of the transformation
dpElement,    # the element of the direct product to be returned
        i,            # counter through all elements of the vector
DP,       # a direct product of groups
elms,       # elements of the group the transformation acts on
vec;       # the transformation as a vector

    DP := SizeFoldDirectProduct( Source( t ) );
    elms := AsSSortedList( Source( t ) );
    dpElement := Identity( DP );
    vec := ImageListOfTransformation( t!.transformation );

    dpElement := Product( [1..Length(vec)],
   i -> Image (Embedding (DP, i), elms[ vec[i] ])
   );

    return dpElement;
  end );

#############################################################################
##
#M  TransformationNearRing    The Complete M(G)
##
## secret components:
## GtoG:  G^|G|
## elementsInfo: the group the mappings act on

InstallMethod(
TransformationNearRing,
"generic",
true,
[IsGroup],
0,
  function ( group )
  local fam, TfmNR;
    fam := EndoMappingFamily( group );

    TfmNR := Objectify(
  NewType(CollectionsFamily(fam),
  IsTransformationNearRingRep),
  rec() );

    TfmNR!.elementsInfo := group;

    SetGamma( TfmNR, group );
    SetOne( TfmNR, IdentityMapping( group ) );
    SetGroupReduct( TfmNR, SizeFoldDirectProduct( group ) );
    SetIsFullTransformationNearRing( TfmNR, true );

    return TfmNR;
  end );

#############################################################################
##
#M  TransformationNearRingByGenerators  From a list of
##      GroupTransformations
##
## secret components:
## elmentsFam: family of its elements
## GtoG:  G^|G|, where G is the group the tfms act on

InstallMethod(
TransformationNearRingByGenerators,
"generic",
true,
[IsGroup, IsList],
0,
  function ( group, gens )
  local fam, TfmNR;
#    if not ForAll(gens,IsMapping) then
# Error("Generators have to be mappings\n");
#    fi;

    # in the case that no generators are given create the trivial near ring
    if gens = [] then
gens := [EndoMappingByTransformation(group,EndoMappingFamily(group),
  TransformationNC(List([1..Size(group)],i->1)))];
    fi;

    fam := FamilyObj(gens[1]);

    if not ForAll( gens, g -> Source(g) = group ) then
Error("generating transformations have to act on the same group\n");
    fi;

    TfmNR := Objectify(
  NewType(CollectionsFamily(fam),
  IsTransformationNearRingRep),
  rec() );

    TfmNR!.elementsInfo := group;

    SetGamma( TfmNR, group);
    SetGeneratorsOfNearRing( TfmNR, gens );

    return TfmNR;
  end );

#############################################################################
##
#M  TransformationNearRingByAdditiveGenerators  From a list of
##       GroupTransformations
##
## secret components:
## elmentsFam: family of its elements

#  constructs the nearring with the help of TransformationNearRingByGenerators
#  and sets the attribute GroupReduct

InstallMethod(
TransformationNearRingByAdditiveGenerators,
"generic",
true,
[IsGroup, IsList],
0,
  function ( group, gens )
  local fam, TfmNR;
    TfmNR := TransformationNearRingByGenerators( group, gens );
    SetGroupReduct( TfmNR,
SubgroupNC( SizeFoldDirectProduct(group),
   List(gens,GroupElementRepOfNearRingElement) ) );

    return TfmNR;
  end );

#############################################################################
##
#M \in   For nearrings with known additive group

InstallMethod(
\in,
"nearrings with known additive group",
IsElmsColls,
[IsNearRingElement and HasGroupElementRepOfNearRingElement, IsNearRing],
0,
  function ( e , nr )
    return GroupElementRepOfNearRingElement(e) in GroupReduct(nr);
  end );

InstallMethod(
\in,
"nearrings with known additive group",
IsElmsColls,
[IsExplicitMultiplicationNearRingElement, IsNearRing],
0,
  function ( e , nr )
    return GroupElementRepOfNearRingElement(e) in GroupReduct(nr);
  end );

InstallMethod(
\in,
"one of the generators",
IsElmsColls,
[IsNearRingElement, IsNearRing and HasGeneratorsOfNearRing],
0,
  function ( e, nr )
    if e in GeneratorsOfNearRing(nr) then
return true;
    else
TryNextMethod();
    fi;
  end );

#############################################################################
##
#M  Enumerator  For transformation nearrings

InstallMethod(
Enumerator,
true,
[ IsTransformationNearRing ],
0,
  function( nr )
    return Objectify( NewType( FamilyObj( nr ),
   IsList and IsTransformationNearRingEnumerator ),
           rec( groupReduct := GroupReduct(nr),
  elementsInfo := nr!.elementsInfo )
);
  end );

#####################################################################
##
#M  Length   for nearring enumerators

InstallMethod(
Length,
true,
[ IsList and IsTransformationNearRingEnumerator ],
0,
    e -> Size( e!.groupReduct ) );

#####################################################################
##
#M  \[\]   for nearring enumerators

InstallMethod(
\[\],
true,
[ IsList and IsTransformationNearRingEnumerator, IsPosInt ],
0,
  function( e, pos )
  local groupElement, group;
    group := e!.groupReduct;
    groupElement := Enumerator(group)[pos];

    return NearRingElementByGroupRep( e!.elementsInfo, groupElement );
  end );

#####################################################################
##
#M  Position   for nearring enumerators

InstallMethod(
Position,
true,
[ IsList and IsTransformationNearRingEnumerator, IsGroupGeneralMapping, IsZeroCyc ],
0,
  function( e, nrelm, zero )
  local groupElement;
    groupElement := GroupElementRepOfNearRingElement(nrelm);

    return Position( e!.groupReduct, groupElement, zero );
  end );

#####################################################################
##
#M  ViewObj   for nearring enumerators
#
InstallMethod(
ViewObj,
true,
[ IsTransformationNearRingEnumerator ],
0,
  function( G )
    Print( "<enumerator of near ring>" );
  end );

#############################################################################
##
#M  Random    For nearrings with known additive group

InstallMethod(
Random,
"Random for nearrings with known additive group",
true,
[IsNearRing and IsExplicitMultiplicationNearRing],
0,
  function ( nr )
    return NearRingElementByGroupRep( nr!.elementsInfo, Random( GroupReduct(nr) ) );
  end );

InstallMethod(
Random,
"Random for nearrings with known additive group",
true,
[IsNearRing and IsTransformationNearRing],
0,
  function ( nr )
    return GroupGeneralMappingByGroupElement( Gamma(nr), Random( GroupReduct(nr) ) );
  end );

#############################################################################
##
#M  IsFullTransformationNearRing  For TfmNRs

InstallMethod(
IsFullTransformationNearRing,
"TfmNRs",
true,
[IsTransformationNearRing],
0,
  function ( TfmNR )
    return Size(TfmNR) = Size( Gamma(TfmNR) )^Size( Gamma(TfmNR) );
  end );

#############################################################################
##
#M  ViewObj  For transformation nearrings

InstallMethod(
ViewObj,
"for TfmNRs",
true,
[IsTransformationNearRing and HasGroupReduct],
2,
  function ( TfmNR )
    Print("TransformationNearRingBySubgroup(");
    View( GroupReduct( TfmNR ) );
    Print(", ... )");
  end );

InstallMethod(
PrintObj,
"for TfmNRs",
true,
[IsTransformationNearRing and HasGroupReduct],
2,
  function ( TfmNR )
    Print("TransformationNearRingBySubgroup(");
    Print( GroupReduct( TfmNR ) );
    Print(", ... )");
  end );

InstallMethod(
ViewObj,
"for TfmNRsByGenerators",
true,
[IsTransformationNearRing and HasGeneratorsOfNearRing],
4,
  function ( TfmNR )
    if Length( GeneratorsOfNearRing(TfmNR) ) > 2 then
Print("< transformation nearring with ",
        Length( GeneratorsOfNearRing(TfmNR) ),
              " generators >" );
    else
TryNextMethod();
    fi;
  end );

InstallMethod(
ViewObj,
"for TfmNRsByGenerators",
true,
[IsTransformationNearRing and HasGeneratorsOfNearRing],
3,
  function ( TfmNR )
    Print("TransformationNearRingByGenerators(");
    View( GeneratorsOfNearRing(TfmNR) );
    Print(")");
  end );

InstallMethod(
PrintObj,
"for TfmNRsByGenerators",
true,
[IsTransformationNearRing and HasGeneratorsOfNearRing],
3,
  function ( TfmNR )
    Print("TransformationNearRingByGenerators(");
    Print( GeneratorsOfNearRing(TfmNR) );
    Print(")");
  end );

InstallMethod(
ViewObj,
"for full transformation NearRings",
true,
[IsTransformationNearRing and HasIsFullTransformationNearRing
  and IsFullTransformationNearRing],
2,
  function ( TfmNR )
    Print( "TransformationNearRing(" );
    View( Gamma(TfmNR) );
    Print( ")" );
  end );

InstallMethod(
PrintObj,
"for full transformation nearrings",
true,
[IsTransformationNearRing and HasIsFullTransformationNearRing
  and IsFullTransformationNearRing],
2,
  function ( TfmNR )
    Print("TransformationNearRing(",Gamma(TfmNR),")");
  end );

#############################################################################
##
#F  ClosureNearRing( <transformations> )
##
##  compute the closure of the <transformations> under addition and
##  composition.

ClosureNearRing := function( mappings )

#JE diese Funktion sollte lieber mit Transformationen arbeiten!

  local closure, Closure, # the constructed closure
group,    # the group on which the tf's operate
        elms,             # the elements of group
        l,                # the number of the elements
        firstrun,         # help var: indicates if first loop run
        tfl,tfl1,tfl2,    # help vars: transformation lists
        elmset,           # help var: contains the elms curr. in the closure
        changed_elmset,   # help var: indicates if elmset has changed
        done,             # help var: indicates, when it is time to stop
        tfs, gens, fam;

    # perform a simple closure algorithm
    tfs      := Flat( [ mappings ] );
    gens     := Set( List( tfs, t ->
ImageListOfTransformation(
   TransformationRepresentation(t)!.transformation) ) );
    closure  := ShallowCopy( gens );
    group    := Source(tfs[1]);
    fam      := EndoMappingFamily( group );
    elms     := AsSSortedList(group);
    l        := Length( elms );
    firstrun := true;
#    Print( closure, "\n" );

    repeat
      # step 1: add all sums
      Info( InfoNearRing,1,"Step 1: Building sums of full mappings" );
      elmset         := closure;
      changed_elmset := true;
      done           := true;
      while changed_elmset do
        closure        := ShallowCopy( elmset );
        changed_elmset := false;
        for tfl1 in closure do
          for tfl2 in     gens     do
            tfl := List( [1..l], i ->
                     Position( elms, elms[ tfl1[i] ] * elms[ tfl2[i] ] ) );
            if not tfl in elmset then
              AddSet( elmset, tfl );
              Info( InfoNearRing, 3, "Adding", tfl );
              changed_elmset := true;
              done           := false;
            fi;
          od;
        od;
      od;
      if not done or firstrun then
        # step 2 build the multiplicative closure
        Info( InfoNearRing, 1, "Step 2: Multiplying full mappings" );
        firstrun       := false;
        elmset         := closure;
        changed_elmset := true;
        done           := true;
        while changed_elmset do
          closure        := ShallowCopy( elmset );
          changed_elmset := false;
          for tfl1 in    gens  do
            for tfl2 in     closure     do
              tfl := tfl1{ tfl2 };
              if not tfl in elmset then
                AddSet( elmset, tfl );
                Info( InfoNearRing, 3, "Adding", tfl );
                changed_elmset := true;
                done           := false;
              fi;
            od;
          od;
          Info( InfoNearRing, 2, "size:", Length( elmset ) );
        od;
      fi;
    until done;
    Closure := [];
    for tfl in closure do
      AddSet( Closure,
EndoMappingByTransformation( group, fam, Transformation( tfl ) ) );
    od;

  return Closure;

end;

#############################################################################
##
#M  ConstantEndoMapping ( <G>, <g> )

InstallMethod(
ConstantEndoMapping,
"default",
IsCollsElms,
[IsGroup, IsMultiplicativeElementWithInverse],
0,
  function ( G , g )
    return MappingByFunction( G, G, x -> g );
  end );

#############################################################################
##
#M  GraphOfMapping ( <m> )
##
InstallMethod(
GraphOfMapping,
"default",
true,
[IsMapping],
0,
  function ( m )
    return List (Source (m), x -> [x, Image (m, x)]);
  end );

#############################################################################
##
#M  GroupReduct( <transformation nearring> )
##

InstallMethod(
GroupReduct,
"TfmNRs",
true,
[IsTransformationNearRing and HasGeneratorsOfNearRing],
0,
  function ( nr )
  local gensAsGroupElms, id;
    gensAsGroupElms :=
List( GeneratorsOfNearRing( nr ), GroupElementRepOfNearRingElement );
    id := gensAsGroupElms[1]^0;

    return NRClosureOfSubgroup( Group( gensAsGroupElms, id ),
    gensAsGroupElms,
    Gamma(nr) );
  end );

#############################################################################
##
#M  SubNearRingBySubgroupNC
##
##  No Check!

InstallMethod(
SubNearRingBySubgroupNC,
"TfmNRs",
true,
[IsTransformationNearRing, IsGroup],
0,
  function ( nr, sg )
  local addGens, subnr;
    addGens := List( GeneratorsOfGroup(sg),
   gen -> NearRingElementByGroupRep( Gamma(nr), gen ) );
    subnr := TransformationNearRingByAdditiveGenerators( Gamma(nr), addGens );
    SetParent( subnr, nr );

    return subnr;
  end );

InstallMethod(
SubNearRingBySubgroupNC,
"TfmNRs",
true,
[IsTransformationNearRing, IsGroup],
2,
  function ( nr, sg )
  local addGens, subnr;
    subnr := Objectify(
  NewType( FamilyObj(nr), IsTransformationNearRingRep), rec() );

    subnr!.elementsInfo := nr!.elementsInfo;

    SetGamma( subnr, Gamma( nr ) );
    SetGroupReduct( subnr, sg );

    SetParent( subnr, nr );

    return subnr;
  end );

#############################################################################
##
#M  InvariantSubNearRings  for M(G)
##

InstallMethod(
InvariantSubNearRings,
"M(G)",
true,
[IsTransformationNearRing and IsFullTransformationNearRing],
0,
  function ( nr )
  local gamma, gens, invsnr;
    gamma := Gamma( nr );
    gens := List( GeneratorsOfGroup(gamma),
   gen -> ConstantEndoMapping( gamma, gen ) );
    gens := List( gens, GroupElementRepOfNearRingElement );

    invsnr := SubgroupNC( GroupReduct(nr), gens );

    return [ nr, SubNearRingBySubgroupNC( nr, invsnr ),
SubNearRingBySubgroupNC( nr, TrivialSubgroup( GroupReduct( nr) ) ) ];
  end );

#############################################################################
##
#M  IsConstantEndoMapping  generic method

InstallMethod(
IsConstantEndoMapping,
"generic",
true,
[IsMapping],
0,
  m -> Size( Image( m ) ) = 1
);

#############################################################################
##
#M  AsExplicitMultiplicationNearRing
##

InstallMethod(
AsExplicitMultiplicationNearRing,
"transformation nearrings",
true,
[IsTransformationNearRing],
0,
  function ( nr )
  local gamma, mul;
    gamma := Gamma(nr);
    mul := function ( a, b )
return GroupElementRepOfNearRingElement( NearRingElementByGroupRep( gamma, a ) * NearRingElementByGroupRep( gamma, b ) );
    end;
    return ExplicitMultiplicationNearRingNC( GroupReduct( nr ), mul );
  end );

############################################################################
## MATRIX NEARRINGS                                                        #
############################################################################

#############################################################################
##
#M  MatrixNearRing   a la  K. Smith

InstallMethod(
MatrixNearRing,
"a la K. Smith",
true,
[IsGroup and IsNGroup, IsInt and IsPosRat],
0,
  function( ng, n )
  local cr_i, fr_ij, r, i, j, nr, mat, gamma, action, i_i, pi_j, MvdWFct;
    nr := NearRingActingOnNGroup( ng );
    action := ActionOfNearRingOnNGroup( ng );
    gamma := DirectProduct( List( [1..n], i -> ng ) );
    fr_ij := [];
    for r in GeneratorsOfNearRing( nr ) do
      for i in [1..n] do
i_i := Embedding( gamma, i );
        for j in [1..n] do
          pi_j := Projection( gamma, j );
   MvdWFct := dpElm -> Image( i_i, action( r, dpElm^pi_j ) );
          Add( fr_ij, MappingByFunction( gamma, gamma, MvdWFct ) );
        od;
      od;
    od;

    mat := TransformationNearRingByGenerators( gamma, fr_ij );

    SetMatrixNearRingFlag( mat, true );
    SetDimensionOfMatrixNearRing( mat, n );
    SetCoefficientRange( mat, nr );

    return mat;
  end );

#############################################################################
##
#M  MatrixNearRing   for d.g. nearrings

InstallMethod(
MatrixNearRing,
"d.g. case",
true,
[IsGroup and IsNGroup, IsInt and IsPosRat],
2,
  function( ng, n )
  local fr_ij, r, i, j, nr, mat, gamma, action, i_i, pi_j, MvdWFct;
    nr := NearRingActingOnNGroup( ng );
    if not( HasIsDgNearRing( nr ) and IsDgNearRing( nr ) ) then
TryNextMethod();
    fi;
    action := ActionOfNearRingOnNGroup( ng );
    gamma := DirectProduct( List( [1..n], i -> ng ) );
    fr_ij := [];
    for r in DistributiveElements( nr ) do
      for i in [1..n] do
i_i := Embedding( gamma, i );
        for j in [1..n] do
          pi_j := Projection( gamma, j );
   MvdWFct := dpElm -> Image( i_i, action( r, dpElm^pi_j ) );
          Add( fr_ij, MappingByFunction( gamma, gamma, MvdWFct ) );
        od;
      od;
    od;

    mat := TransformationNearRingByAdditiveGenerators( gamma, fr_ij );

    SetMatrixNearRingFlag( mat, true );
    SetDimensionOfMatrixNearRing( mat, n );
    SetCoefficientRange( mat, nr );

    return mat;
  end );

#############################################################################
##
#M  ViewObj    for matrix nearrings

InstallMethod(
ViewObj,
"matrix nearrings",
true,
[IsNearRing and IsMatrixNearRing],
5,
  function( nr )
    Print( "MatrixNearRing( ",CoefficientRange(nr),", ",
   DimensionOfMatrixNearRing(nr)," )" );
  end );

#############################################################################
##
#M  IsAbelianNearRing   for matrix nearrings

InstallMethod(
IsAbelianNearRing,
"matrix nearrings",
true,
[IsNearRing and IsMatrixNearRing],
0,
  function( m )
    return IsAbelianNearRing( CoefficientRange( m ) );
  end );

#############################################################################
##
#M  IsZeroSymmetricNearRing  for matrix nearrings

InstallMethod(
IsZeroSymmetricNearRing,
"matrix nearrings",
true,
[IsNearRing and IsMatrixNearRing],
0,
  function( m )
    return IsZeroSymmetricNearRing( CoefficientRange( m ) );
  end );

#############################################################################
##
#M  IsAbstractAffineNearRing  for matrix nearrings

InstallMethod(
IsAbstractAffineNearRing,
"matrix nearrings",
true,
[IsNearRing and IsMatrixNearRing],
2,
  function( m )
    if IsAbstractAffineNearRing( CoefficientRange( m ) ) then
return true;
    else
TryNextMethod();
    fi;
  end );

#############################################################################
##
#F  Ntimesg( <nr>, <g> )
#F  IsDistributiveNearRingElement( <nr>, <n> )
##

Ntimesg := function( N, g )
local E, Ng, e, i, G, fine_so_far;

  E := GeneratorsOfNearRing( N );
  Ng := Group( Set( List( E, n -> ImageElm( n, g ) ) ), g^0 );

  e := 0;
  while e < Length(E) do
    e := e + 1;
    i := 0;
    G := Enumerator(Ng);
    fine_so_far := true;
    while fine_so_far and i < Size(Ng) do
      i := i + 1;
      if not ( ImageElm( E[e], G[i] ) in Ng ) then
fine_so_far := false;
      fi;
    od;
    if not fine_so_far then
      Ng := ClosureGroup( Ng, ImageElm( E[e], G[i] ) );
      e := 0;
    fi;
  od;

  return Ng;
end;

#IsDistributiveNearRingElement := function ( nr, n )
#local gamma, Ng, Ngs, CheckedNgs, i, h;
#
#  gamma := Gamma( nr );
#  Ngs := List( gamma, g -> Ntimesg( nr, g ) );
#  CheckedNgs := [];
#  i := 0;
#
#  while i < Length(Ngs) do
#    i := i + 1;
#    Ng := Ngs[i];
#    if ForAll( CheckedNgs, BigOne -> not ( IsSubset( BigOne, Ng ) ) ) then
#      h := MappingByFunction( Ng, Ng, x -> Image( n, x ) );
#      if not IsGroupHomomorphism( h ) then
# return false;
#      fi;
#    fi;
#  od;
#
#  return true;
#end;

#############################################################################
##
#M  DistributiveElements  for TfmNrs
##

InstallMethod(
DistributiveElements,
"TfmNrs",
true,
[IsNearRing and IsTransformationNearRing],
0,
  function ( nr )
  local gamma, Ng, Ngs, CheckedNgs, i, j, h, distr, all_endos, n;

    gamma := Gamma( nr );
    Ngs := List( gamma, g -> Ntimesg( nr, g ) );

    for i in [1..Length(Ngs)] do
      if ForAny( [1..Length(Ngs)], j -> i<>j and
     IsBound(Ngs[j]) and
     IsSubset( Ngs[j], Ngs[i] )
  ) then
   Unbind( Ngs[i] );
      fi;
    od;
    Ngs := Flat(Ngs);

    distr := [];

    for n in nr do
      CheckedNgs := [];
      i := 0;
      all_endos := true;
      while all_endos and i < Length(Ngs) do
i := i + 1;
Ng := Ngs[i];
        h := MappingByFunction( Ng, Ng, x -> ImageElm( n, x ) );
        if not IsGroupHomomorphism( h ) then
   all_endos := false;
        fi;
      od;
      if all_endos then
        Add( distr, n );
      fi;
    od;

    return distr;
  end );

#########################################################################
##
#M  IsDistributiveNearRing
##

InstallMethod(
IsDistributiveNearRing,
"abelian near ring (Binder e.a.)",
true,
[IsNearRing and IsTransformationNearRing],
50,
  function( nr )
    local F, G, E, gamma;
    gamma := Gamma( nr );
    if not IsAbelian(gamma) then
      TryNextMethod();
    fi;
    F := AdditiveGenerators( nr );
    for gamma in Gamma( nr ) do
      G := Ntimesg( nr, gamma );
      E := GeneratorsOfGroup( G );
      if ForAny( F, f -> ForAny( G, g -> ForAny( E, e ->
  Image( f, g*e ) <> Image( f, g ) * Image( f, e ) ) ) ) then
return false;
      fi;
    od;
    return true;
  end);

#########################################################################
##
#M  SomeInvariantSubgroupsOfGamma
##

InstallMethod(
SomeInvariantSubgroupsOfGamma,
"default",
true,
[IsNearRing and IsTransformationNearRing],
0,
  function( nr )
  local E, gamma, g, new, invsg;
    E := GeneratorsOfNearRing( nr );
    gamma := Gamma( nr );
    invsg := [];
    for g in gamma do
      if ForAll( invsg, I -> not (g in I) ) then
        new := Ntimesg( nr, g );
invsg := Filtered( invsg, I -> not( IsSubgroup( new, I ) ) );
Add( invsg, new );
      fi;
    od;

    return invsg;
  end );

#########################################################################
##
#M  IsDistributiveNearRingElement( <nr>, <elm> )
##
##  returns true if <elm> distributes over all elements of <nr>
##

InstallMethod(
IsDistributiveNearRingElement,
"TfmNRs",
IsCollsElms,
[IsNearRing and IsTransformationNearRing, IsNearRingElement],
0,
  function ( nr, n )
  local Ngs, i, h, Ng, NgGens, g, e;

  Ngs := SomeInvariantSubgroupsOfGamma( nr );
  i := 0;

  while i < Length(Ngs) do
    i := i + 1;
    Ng := Ngs[i];
    NgGens := GeneratorsOfGroup( Ng );
    for g in Ng do
      for e in NgGens do
if ImageElm( n, g * e ) <> ImageElm( n, g ) * ImageElm( n, e ) then
   return false;
fi;
      od;
    od;
  od;

  return true;
end );

#########################################################################
##
#M  DistributiveElements  for transformation nearrings
##

InstallMethod(
DistributiveElements,
"TfmNrs",
true,
[IsNearRing and IsTransformationNearRing],
10,
  function ( nr )
  local gamma, Ng, NgGens, Ngs, i, h, distGens, distr, all_endos, n, g, e;

    gamma := Gamma( nr );
    Ngs := SomeInvariantSubgroupsOfGamma( nr );
    distr := [];

    for n in ZeroSymmetricPart(nr) do
     if not n in distr then
      i := 0;
      all_endos := true;
      while all_endos and i < Length(Ngs) do
i := i + 1;
Ng := Ngs[i];
NgGens := GeneratorsOfGroup( Ng );
for g in Ng do
   for e in NgGens do
     if ImageElm( n, g * e ) <> ImageElm( n, g ) * ImageElm( n, e ) then
  all_endos := false;
     fi;
   od;
od;
      od;
      if all_endos then
UniteSet( distr,
  AsSSortedList( Semigroup(TransformationRepresentation(n) ) ) );
      fi;
     fi;
    od;

    return distr;
  end );

#########################################################################
##
#M  GroupReduct TfmNRs generated by distributive elements
##

InstallMethod(
GroupReduct,
"distributive generators",
true,
[IsNearRing and IsTransformationNearRing],
50,
  function ( tfmnr )
  local gens;
    gens := GeneratorsOfNearRing( tfmnr );
# distributivity can be checked without knowing all elements of the nr
    if not ForAll( gens, g -> IsDistributiveNearRingElement( tfmnr, g ) ) then
TryNextMethod(); # the default closure algorithm
    fi;

    Info( InfoNearRing, 1, "computing multiplicative semigroup" );
    gens := List( gens, TransformationRepresentation );
    gens := AsList( Semigroup( gens ) );

    return Group( List( gens, GroupElementRepOfNearRingElement ) );
  end );

#########################################################################
##
#M  IsIdentityMapping
##

InstallMethod(
IsIdentityMapping,
"compare with identity mapping",
true,
[IsGroupGeneralMapping],
0,
  m -> m = IdentityMapping( Source(m) )
);

#########################################################################
##
#M  AsList   for TfmNRs
##

InstallMethod(
AsList,
"for TfmNRs",
true,
[IsNearRing and IsTransformationNearRing],
0,
  function( nr )
  local G;
    G := Gamma( nr );
    return List( AsList( GroupReduct(nr) ),
   t -> GroupGeneralMappingByGroupElement( G, t ) );
  end );

#########################################################################
##
#M   EndoMappingByPositionList
##

InstallMethod(
EndoMappingByPositionList,
"list -> endomapping",
true,
[IsGroup,IsList],
0,
  function( G, list )
    return EndoMappingByTransformation( G,
          EndoMappingFamily( G ),
          Transformation( list) );
  end );

#########################################################################
##
#M   EndoMappingByFunction
##

InstallMethod(
EndoMappingByFunction,
"function -> endomapping",
true,
[IsGroup, IsFunction],
0,
  function( G, fun )
  #
      local elementsOfG;
  #
    elementsOfG := AsSSortedList (G);
    return EndoMappingByPositionList (G,
                                      List ([1..Size (G)],
                                      i -> Position (
                                             elementsOfG,
                                             fun (elementsOfG [i])
                                                    )
                                           )
                                     );
  end );

#########################################################################
##
#M   AsEndoMapping
##

InstallMethod(
        AsEndoMapping,
"mapping -> endomapping",
true,
[IsMapping],
0,
  function( map )
  #
      local G;
  #
  if not (IsGroup (Source (map)) and
          IsGroup (Range  (map)) and
          IsIdenticalObj (Source (map), Range (map))) then
     TryNextMethod ();
  fi;
  #
  G := Source (map);
  return EndoMappingByFunction (G, x -> Image ( map, x ));
  end);

#########################################################################
##
#M   IdentityEndoMapping
##

InstallMethod(
        IdentityEndoMapping,
"identity on G",
true,
[IsGroup],
0,
  function( G )
     return  EndoMappingByFunction ( G, x -> x );
  end);

#########################################################################
##
#M   IsIdentityEndoMapping
##

InstallMethod(
        IsIdentityEndoMapping,
"is identity on G",
true,
[IsEndoMapping],
0,
  function( endomap )
     return IsIdentityMapping ( endomap );
  end);

#########################################################################
##
#M   IsDistributiveEndoMapping
##

InstallMethod(
        IsDistributiveEndoMapping,
"is a group homomorphism",
true,
[IsEndoMapping],
0,
  function( endomap )
     return IsGroupHomomorphism ( endomap );
  end);

SSL grptfms.gi Sprache: unbekannt

[ Verzeichnis aufwärts0.57unsichere Verbindung Übersetzung europäischer Sprachen durch Browser ]