Quelle CHAP004.htm Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/sonata/doc/htm/ref/CHAP004.htm

<html><head><title>[SONATA] 4 Arbitrary functions on groups: EndoMappings</title></head>
<body text="#000000" bgcolor="#ffffff">
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<h1>4 Arbitrary functions on groups: EndoMappings</h1>

<H3>Sections</H3>
<oL>
<li> <A HREF="CHAP004.htm#SECT001">Defining endo mappings</a>
<li> <A HREF="CHAP004.htm#SECT002">Properties of endo mappings</a>
<li> <A HREF="CHAP004.htm#SECT003">Operations for endo mappings</a>
<li> <A HREF="CHAP004.htm#SECT004">Nicer ways to print a mapping</a>
</ol>

An endomapping is a mapping with equal source and range, say G,
where G is a group. An endomapping on G then acts on G by
transforming each element of G into (precisely one) element of G.
Endomappings are special cases of Mappings.

Endomappings are created by the constructor functions
<code>EndoMappingByPositionList</code>, <code>EndoMappingByFunction</code>, <code>IdentityEndoMapping</code>,
<code>ConstantEndoMapping</code>, and are represented as mappings.
The functions described in
this section can be found in the file <code>grptfms.g?</code>.


<h2><a name="SECT001">4.1 Defining endo mappings</a></h2>

<a name = "SSEC001.1"></a>
<li><code>EndoMappingByPositionList ( </code><var>G</var><code>, </code><var>list</var><code> )</code>

The constructor function <code>EndoMappingByPositionList</code> returns the
the endomapping that maps the i-th element of the group (in the
ordering given by AsSortedList)
to the i-th element of list.

<pre>
 gap> G := GTW4_2;
 4/2
 gap> t1 := EndoMappingByPositionList ( G, [1, 2, 4, 4] );
 <mapping: 4/2 -> 4/2 >
</pre>

<a name = "SSEC001.2"></a>
<li><code>EndoMappingByFunction( </code><var>G</var><code>, </code><var>fun</var><code> )</code>

The constructor function <code>EndoMappingByFunction</code> returns the
function <var>fun</var> that maps elements of the group <var>G</var> into <var>G</var> as an
endomapping.

<pre>
 gap> t2 := EndoMappingByFunction ( GTW8_2, g -> g^-1 );
 <mapping: 8/2 -> 8/2 >
 gap> IsGroupHomomorphism ( t2 );
 true
 gap> t3 := EndoMappingByFunction ( GTW6_2, g -> g^-1 );
 <mapping: 6/2 -> 6/2 >
 gap> IsGroupHomomorphism ( t3 );
 false
</pre>

<code>EndoMappings</code> and <code>GroupGeneralMappings</code> are different
kinds of objects in GAP: <code>GroupGeneralMappings</code> model homomorphisms between
two different groups, whereas <code>EndoMappings</code> model nonlinear functions
on one group.
However, <code>GroupGeneralMappings</code> can be transformed into
<code>Endomappings</code> if they have equal source and range.

<a name = "SSEC001.3"></a>
<li><code>AsEndoMapping( </code><var>map</var><code> )</code>

The constructor function <code>AsEndoMapping</code> returns the mapping <var>map</var>
as an endomapping.

<pre>
 gap> G1 := Group ((1,2,3), (1, 2));
 Group([ (1,2,3), (1,2) ])
 gap> G2 := Group ((2,3,4), (2, 3));
 Group([ (2,3,4), (2,3) ])
 gap> f1 := IsomorphismGroups ( G1, G2 );
 [ (1,2,3), (1,2) ] -> [ (2,3,4), (2,3) ]
 gap> f2 := IsomorphismGroups ( G2, G1 );
 [ (2,3,4), (2,3) ] -> [ (1,2,3), (1,2) ]
 gap> AsEndoMapping ( CompositionMapping ( f1, f2 ) );
 <mapping: Group( [ (2,3,4), (2,3) ] ) -> Group( [ (2,3,4), (2,3)
 ] ) >
</pre>

<code>EndoMappings</code> and <code>GroupGeneralMappings</code> are two completely different
kinds of objects in GAP, but they can be transformed into one
another.

<a name = "SSEC001.4"></a>
<li><code>AsGroupGeneralMappingByImages( </code><var>endomap</var><code> )</code>

<code>AsGroupGeneralMappingByImages</code> returns the
<code>GroupGeneralMappingByImages</code> that acts on the group the same way as
the endomapping <var>endomap</var>. It only makes sense to use this function
for endomappings that are group endomorphisms.

<pre>
 gap> m := IdentityEndoMapping ( GTW6_2 );
 <mapping: 6/2 -> 6/2 >
 gap> AsGroupGeneralMappingByImages ( m );
 [ (1,2), (1,2,3) ] -> [ (1,2), (1,2,3) ]
</pre>

<a name = "SSEC001.5"></a>
<li><code>IsEndoMapping( </code><var>obj</var><code> )</code>

<code>IsEndoMapping</code> returns <code>true</code> if the object <var>obj</var> is an endomapping
and <code>false</code> otherwise.

<pre>
 gap> IsEndoMapping ( InnerAutomorphisms ( GTW6_2 ) [3] );
 true
</pre>

<a name = "SSEC001.6"></a>
<li><code>IdentityEndoMapping( </code><var>G</var><code> )</code>

<code>IdentitEndoMapping</code> is the counterpart to the GAP standard
library function <code>IdentityMapping</code>. It returns the identity
transformation on the group <var>G</var>.

<pre>
 gap> AsList ( UnderlyingRelation ( IdentityEndoMapping ( Group ((1,2,3,4)) ) ) );
 [ DirectProductElement( [ (), () ] ), DirectProductElement( [ (1,2,3,4), (1,2,
 3,4) ] ), DirectProductElement( [ (1,3)(2,4), (1,3)(2,4) ] ),
 DirectProductElement( [ (1,4,3,2), (1,4,3,2) ] ) ]
</pre>

<a name = "SSEC001.7"></a>
<li><code>ConstantEndoMapping( </code><var>G</var><code>, </code><var>g</var><code> )</code>

<code>ConstantEndoMapping</code> returns the endomapping on the group <var>G</var>
which maps everything to the group element <var>g</var> of <var>G</var>.

<pre>
 gap> C3 := CyclicGroup (3);
 <pc group of size 3 with 1 generator>
 gap> m := ConstantEndoMapping (C3, AsSortedList (C3) [2]);
 MappingByFunction( <pc group of size 3 with
 1 generator>, <pc group of size 3 with
 1 generator>, function( x ) ... end )
 gap> List (AsList (C3), x -> Image (m, x));
 [ f1, f1, f1 ]
</pre>


<h2><a name="SECT002">4.2 Properties of endo mappings</a></h2>

<a name = "SSEC002.1"></a>
<li><code>IsIdentityEndoMapping( </code><var>endomap</var><code> )</code>

<code>IsIdentityEndoMapping</code> returns <code>true</code> if <var>endomap</var> is the identity
function on a group.

<pre>
 gap> IsIdentityEndoMapping (EndoMappingByFunction (
 > AlternatingGroup ( [1..5] ), x -> x^31));
 true
</pre>

<a name = "SSEC002.2"></a>
<li><code>IsConstantEndoMapping( </code><var>endomap</var><code> )</code>

<code>IsConstantEndoMapping</code> returns <code>true</code> if the endomapping
<var>endomap</var> is constant and <code>false</code> otherwise.

<pre>
 gap> C3 := CyclicGroup ( 3 );
 <pc group of size 3 with 1 generator>
 gap> IsConstantEndoMapping ( EndoMappingByFunction ( C3, x -> x^3 ));
 true
</pre>

<a name = "SSEC002.3"></a>
<li><code>IsDistributiveEndoMapping( </code><var>endomap</var><code> )</code>

A mapping t on an (additively written) group G is called
distributive if for all elements x and y in G:\
t(x+y) = t(x) + t(y).
The function <code>IsDistributiveEndoMapping</code> returns the according
boolean value <code>true</code> or <code>false</code>.

<pre>
 gap> G := Group ( (1,2,3), (1,2) );
 Group([ (1,2,3), (1,2) ])
 gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^3));
 false
 gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^7));
 true
</pre>


<h2><a name="SECT003">4.3 Operations for endo mappings</a></h2>

While the composition operator <code>*</code> is applicable to mappings and
transformations, the operation <code>+</code> (pointwise addition of the images) can
only be applied to transformations.

The product operator <code>*</code> returns the transformation which is obtained
from the transformations <var>t1</var> and <var>t2</var> by composition of <var>t1</var> and <var>t2</var>
(i.e. performing <var>t2</var> after <var>t1</var>).

<pre>
 gap> t1 := ConstantEndoMapping ( GTW2_1, ());
 MappingByFunction( 2/1, 2/1, function( x ) ... end )
 gap> t2 := ConstantEndoMapping (GTW2_1, (1, 2));
 MappingByFunction( 2/1, 2/1, function( x ) ... end )
 gap> List ( AsList ( GTW2_1 ), x -> Image ( t1 * t2, x ));
 [ (1,2), (1,2) ]
</pre>

The add operator <code>+</code> returns the endomapping which is obtained
from the endomappings <var>t1</var> and <var>t2</var> by pointwise addition
of <var>t1</var> and <var>t2</var>. (Note that in this context addition means that
for every place x in the source of <var>t1</var> and <var>t2</var>,
GAP performs the operation <code>p * q</code>, where
<code>p</code> is the image of <var>t1</var> at x and <code>q</code> is the image of <var>t2</var> at x.)

The subtract operator <code>-</code> returns the endomapping which is
obtained from the endomappings <var>t1</var> and <var>t2</var> by pointwise
subtraction of <var>t1</var> and <var>t2</var>. (Note that in this context subtraction
means performing the GAP operation <code>p * q^(-1)</code>,
where
<code>p</code> is the image of <var>t1</var> at a place x and <code>q</code> is the image of <var>t2</var> at x.)

<pre>
 gap> G := SymmetricGroup ( 3 );
 Sym( [ 1 .. 3 ] )
 gap> invertingOnG := EndoMappingByFunction ( G, x -> x^-1 );
 <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup(
 [ 1 .. 3 ] ) >
 gap> identityOnG := IdentityEndoMapping (G);
 <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup(
 [ 1 .. 3 ] ) >
 gap> AsSortedList ( G );
 [ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ]
 gap> List ( AsSortedList (G),
 > x -> Image ( identityOnG * invertingOnG, x ));
 [ (), (2,3), (1,2), (1,3,2), (1,2,3), (1,3) ]
 gap> List ( AsSortedList (G),
 > x -> Image ( identityOnG + invertingOnG, x ));
 [ (), (), (), (), (), () ]
 gap> IsIdentityEndoMapping ( - invertingOnG );
 true
 gap> - invertingOnG = identityOnG;
 true
</pre>


<h2><a name="SECT004">4.4 Nicer ways to print a mapping</a></h2>

<a name = "SSEC004.1"></a>
<li><code>GraphOfMapping( </code><var>mapping</var><code> )</code>

<code>GraphOfMapping</code> returns the set of all pairs (x,m(x)), where
x lies in the source of the mapping. In particular, it returns
List (Source (m), x -> [x, Image (m, x)]);

<pre>
 gap> G := SymmetricGroup ( 3 );
 Sym( [ 1 .. 3 ] )
 gap> m := ConstantEndoMapping (G, (1,2,3)) + IdentityEndoMapping( G );
 MappingByFunction( Sym( [ 1 .. 3 ] ), Sym( [ 1 .. 3 ] ), function( g ) ... end )
 gap> PrintArray( GraphOfMapping( m ) );
 [ [ (), (1,2,3) ],
 [ (2,3), (1,3) ],
 [ (1,2), (2,3) ],
 [ (1,2,3), (1,3,2) ],
 [ (1,3,2), () ],
 [ (1,3), (1,2) ] ]
</pre>

<a name = "SSEC004.2"></a>
<li><code>PrintAsTerm( </code><var>mapping</var><code> )</code>

If <var>mapping</var> is a polynomial function on its source then <code>PrintAsTerm</code>
prints a polynomial that induces the mapping <var>mapping</var>.
<pre>
 gap> G := SymmetricGroup ( 3 );
 Sym( [ 1 .. 3 ] )
 gap> p := Random( PolynomialNearRing( G ) );
 <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( [ 1 .. 3 ] ) >
 gap> PrintAsTerm( p );
 g1 - x - 2 * g1 - g2 - x - g1 - g2 + g1 - x - 2 * g1 -
 g2 - x - g1 - g2 - 3 * x + g1
 gap> GeneratorsOfGroup( G );
 [ (1,2,3), (1,2) ]
</pre>

The expressions <code>g1</code> and <code>g2</code> stand for the first and secong generator
of the group <var>G</var> respectively. The result is not necessarily a
polynomial of minimal length.


[<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>]

<address>SONATA manual September 2025
</address></body></html>

quality100%

¤ Dauer der Verarbeitung: 0.27 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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.