Quelle cat1.xml Sprache: XML

<?xml version="1.0" encoding="UTF-8"?>

<Chapter Label="chap-cat1">

<Heading>Cat1-algebras</Heading>

<Section>

<Heading>Definitions and examples</Heading>

<Index>cat1-group</Index>

Algebraic structures which are equivalent to crossed modules of algebras include :

<List>
<Item>
cat<M>^{1}</M>-algebras, (Ellis, <Cite Key="ellis1"/>);
</Item>
<Item>
simplicial algebras with Moore complex of length 1,
(Z. Arvasi and T.Porter, <Cite Key="arvasi2"/>);
</Item>
<Item>
algebra-algebroids, (Gaffar Musa's Ph.D. thesis, ).
</Item>
</List>

In this section we describe an implementation of cat<M>^{1}</M>-algebras
and their morphisms.
<P/>
The notion of a cat<M>^{1}</M>-group was defined as an algebraic model
of <M>2</M>-types by Loday in <Cite Key="loday"/>.
Then Ellis defined cat<M>^{1}</M>-algebras in <Cite Key="ellis1"/>.
<P/>
Let <M>A</M> and <M>R</M> be <M>k</M>-algebras,
let <M>t,h:A\rightarrow R</M> be surjections,
and let <M>e:R\rightarrow A</M> be an inclusion.

<Display>
\xymatrix@R=50pt@C=50pt{ A \ar@{->}@<-1.5pt>[d]_{t}
\ar@{->}@<1.5pt>[d]^{h} \\ R \ar@/^1.5pc/[u]^{e}
}
</Display>

If the conditions,
<Display>
\mathbf{Cat1Alg1:} \quad te = id_{R} = he,
\qquad
\mathbf{Cat1Alg2:} \quad (\ker t)(\ker h) = \{0_{A}\}
</Display>
are satisfied, then the algebraic system
<M>\mathcal{C} := (e;t,h : A \rightarrow R)</M>
is called a <E>cat<M>^{1}</M>-algebra</E>.
A system which satisfies the condition
<M>\mathbf{Cat1Alg1}</M> is called a <E>precat<M>^{1}</M>-algebra</E>.
The homomorphisms <M>t,h</M> and <M>e</M> are called the <E>tail map</E>,
<E>head map</E> and <E>range embedding</E> homomorphisms, respectively.

<ManSection>
   <Func Name="Cat1Algebra"
         Arg="args" />
   <Oper Name="PreCat1AlgebraByEndomorphisms"
         Arg="t h" />
   <Oper Name="PreCat1AlgebraByTailHeadEmbedding"
         Arg="t h e" />
   <Func Name="PreCat1Algebra"
         Arg="args" />
   <Prop Name="IsIdentityCat1Algebra"
         Arg="C" />
   <Prop Name="IsCat1Algebra"
         Arg="C" />
   <Prop Name="IsPreCat1Algebra"
         Arg="C" />
<Description>
The operations <C>PreCat1AlgebraByEndomorphisms</C>
and <C>PreCat1AlgebraByTailHeadEmbedding</C>
are used with particular choices of algebra homomorphisms.
The operations listed above are used for the construction of
precat<M>^{1}</M>- and cat<M>^{1}</M>-algebras.
The functions <C>PreCat1Algebra</C> and <C>Cat1Algebra</C>
select the appropriate operation to suit the user's input.
</Description>
</ManSection>

<ManSection>
   <Attr Name="Source" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="Range" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="TailMap" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="HeadMap" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="RangeEmbedding" Label="for cat1-algebras"
         Arg="C" />
   <Meth Name="Kernel" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="KernelEmbedding" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="Boundary" Label="for cat1-algebras"
         Arg="C" />
   <Attr Name="Size2d" Label="for 2d-algebras"
         Arg="C" />
   <Attr Name="Dimension" Label="for 2d-algebras"
         Arg="C" />
<Description>
These are the nine main attributes of a pre-cat<M>^{1}</M>-algebra.
<P/>
In the example we use homomorphisms between <C>A2c6</C> and <C>I2c6</C>
constructed in section <Ref Sect="algebra-homomorphism-lists"/>.
</Description>
</ManSection>

<Example>
<![CDATA[
gap> t4 := homAR[8];
[ (Z(2)^0)*(1,6,5,4,3,2) ] -> [ (Z(2)^0)*(7,9,8) ]
gap> e4 := homRA[8];
[ (Z(2)^0)*(7,8,9) ] -> [ (Z(2)^0)*(1,5,3)(2,6,4) ]
gap> C4 := PreCat1AlgebraByTailHeadEmbedding( t4, t4, e4 );
[AlgebraWithOne( GF(2), [ (Z(2)^0)*(1,2,3,4,5,6)
] ) -> AlgebraWithOne( GF(2), [ (Z(2)^0)*(7,8,9) ] )]
gap> IsCat1Algebra( C4 );
true
gap> Size2d( C4 );
[ 64, 8 ]
gap> Dimension( C4 );
[ 6, 3 ]
gap> Display( C4 );

Cat1-algebra [..=>..] :-
: source algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3,4,5,6) ]
:  range algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*(7,8,9) ]
: tail homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*(7,8,9) ]
: head homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*(7,8,9) ]
: range embedding maps range generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*(1,5,3)(2,6,4) ]
: kernel has generators:
  [ (Z(2)^0)*()+(Z(2)^0)*(1,4)(2,5)(3,6), (Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*
    (1,5,3)(2,6,4), (Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,6,5,4,3,2) ]
: boundary homomorphism maps generators of kernel to:
  [ <zero> of ..., <zero> of ..., <zero> of ... ]
: kernel embedding maps generators of kernel to:
  [ (Z(2)^0)*()+(Z(2)^0)*(1,4)(2,5)(3,6), (Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*
    (1,5,3)(2,6,4), (Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,6,5,4,3,2) ]
]]>
</Example>

<ManSection>
   <Oper Name="Cat1AlgebraSelect"
         Arg="GFnum gpsize gpnum num" />
<Description>
The <Ref Oper="Cat1Algebra"/> function may also be used to select certain
cat<M>^{1}</M>-group-algebras from the data file included with this package.
Data for these cat<M>^{1}</M>-structures on commutative group algebras is
stored in a list in file <File>cat1algdata.g</File>.
This data is read into the list <C>CAT1ALG_LIST</C>
only when this function is called.
<P/>
The function <C>Cat1AlgebraSelect</C> may be used in four ways:
<List>
<Item>
<C>Cat1AlgebraSelect( n )</C> returns the list of possible group orders when
Galois field <M>GF(n)</M>, with <M>n \in [2,3,4,5,7]</M>,
is used to form cat<M>^1</M>-group-algebra structures.
</Item>
<Item>
<C>Cat1AlgebraSelect( n, m )</C> returns the list of available
group numbers of size <M>m</M> with which to form
cat<M>^1</M>-group-algebra structures with given Galois field <M>GF(n)</M>.
</Item>
<Item>
<C>Cat1AlgebraSelect( n, m, k )</C> prints the list of possible
cat<M>^{1}</M>-group-algebra structures with given Galois field <M>GF(n)</M>
and group number <M>k</M> of size <M>m</M>.
The number of these structures is returned.
</Item>
<Item>
<C>Cat1AlgebraSelect( n, m, k, j )</C>
(or simply <C>Cat1Algebra( n, m, k, j )</C>) returns the
<M>j</M>-th cat<M>^{1}</M>-group-algebra structure with these other parameters.
</Item>
</List>
Now, we give examples of the use of this function.
<P/>
</Description>
</ManSection>

<Example>
<![CDATA[
gap> C := Cat1AlgebraSelect( 11 );
|--------------------------------------------------------|
| 11 is invalid value for the Galois Field (GFnum)       |
| Available values for GFnum in the data :               |
|--------------------------------------------------------|
[ 2, 3, 4, 5, 7 ]
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
fail
gap> C := Cat1AlgebraSelect( 4, 12 );
|--------------------------------------------------------|
| 12 is invalid value for size of group (gpsize)         |
| Available values for gpsize with GF(4) in the data:    |
|--------------------------------------------------------|
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
gap> C := Cat1AlgebraSelect( 2, 6, 3 );
|--------------------------------------------------------|
| 3 is invalid value for groups of order 6               |
| Available values for gpnum for groups of size 6 :      |
|--------------------------------------------------------|
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
[ 1, 2 ]
gap> C := Cat1AlgebraSelect( 2, 6, 2 );
There are 4 cat1-structures for the group algebra GF(2)_c6.
Range Alg      Tail                    Head
|--------------------------------------------------------|
| GF(2)_c6      identity map            identity map     |
| -----         [ 2, 10 ]               [ 2, 10 ]        |
| -----         [ 2, 14 ]               [ 2, 14 ]        |
| -----         [ 2, 50 ]               [ 2, 50 ]        |
|--------------------------------------------------------|
Usage: Cat1Algebra( GFnum, gpsize, gpnum, num );
Algebra has generators [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3)(4,5) ]
4
]]>
</Example>

The algebra <C>GF(n)_gp</C> has a list of <M>n^{|gp|}</M> elements.
The <C>[2, 10]</C> in the second structure above
indicates that the tail map, and also the head map,
of the cat<M>^1</M>-algebra maps the two generators of <C>c6</C>
to the second and tenth elements of this algebra respectively.

<Example>
<![CDATA[
gap> C0 := Cat1AlgebraSelect( 4, 6, 2, 2 );
[GF(2^2)_c6 -> Algebra( GF(2^2),
[ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5)(3,6)+(
    Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ] )]
gap> Size2d( C0 );
[ 4096, 1024 ]
gap> Dimension( C0 );
[ 6, 5 ]
gap> Display( C0 );
Cat1-algebra [GF(2^2)_c6=>..] :-
: source algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*(1,2,3,4,5,6) ]
:  range algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5)
    (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
: tail homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5)
    (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
: head homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5)
    (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
: range embedding maps range generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)(2,5)
    (3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
: kernel has generators:
  [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)
    (2,5)(3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
: boundary homomorphism maps generators of kernel to:
  [ <zero> of ... ]
: kernel embedding maps generators of kernel to:
  [ (Z(2)^0)*()+(Z(2)^0)*(1,2,3,4,5,6)+(Z(2)^0)*(1,3,5)(2,4,6)+(Z(2)^0)*(1,4)
    (2,5)(3,6)+(Z(2)^0)*(1,5,3)(2,6,4)+(Z(2)^0)*(1,6,5,4,3,2) ]
]]>
</Example>

<ManSection>
   <Oper Name="SubCat1Algebra"
         Arg="alg src rng" />
   <Oper Name="SubPreCat1Algebra"
         Arg="alg src rng" />
   <Oper Name="IsSubCat1Algebra"
         Arg="alg sub" />
   <Oper Name="IsSubPreCat1Algebra"
         Arg="alg sub" />
<Description>
Let <M>\mathcal{C} = (e;t,h:A\rightarrow R)</M>
be a cat<M>^{1}</M>-algebra, and let <M>A^{\prime}</M>,
<M>R^{\prime}</M> be subalgebras of <M>A</M> and <M>R</M> respectively.
If the restriction morphisms
<Display>
t^{\prime} = t|_{A^{\prime}} : A^{\prime}\rightarrow R^{\prime},
\qquad
h^{\prime} = h|_{A^{\prime}} : A^{\prime}\rightarrow R^{\prime},
\qquad
e^{\prime} = e|_{R^{\prime}} : R^{\prime}\rightarrow A^{\prime}
</Display>
satisfy the <M>\mathbf{Cat1Alg1}</M> and <M>\mathbf{Cat1Alg2}</M>
conditions, then the system
<M>\mathcal{C}^{\prime } = (e^{\prime};t^{\prime},h^{\prime}
  : A^{\prime} \rightarrow R^{\prime})</M>
is called a <E>subcat<M>^{1}</M>-algebra</E> of
<M>\mathcal{C} = (e;t,h:A\rightarrow R)</M>.
<P/>
If the morphisms satisfy only the <M>\mathbf{Cat1Alg1}</M> condition
then <M>\mathcal{C}^{\prime }</M> is called a
<E>sub-precat<M>^{1}</M>-algebra</E> of <M>\mathcal{C}</M>.
<P/>
The operations in this subsection are used for constructing
subcat<M>^{1}</M>-algebras of a given cat<M>^{1}</M>-algebra.

</Description>
</ManSection>

<Example>
<![CDATA[
gap> C6 := Cat1AlgebraSelect( 2, 6, 2, 4 );;
gap> A6 := Source( C6 );
GF(2)_c6
gap> B6 := Range( C6 );
<algebra of dimension 3 over GF(2)>
gap> eA6 := Elements( A6 );;
gap> eB6 := Elements( B6 );;
gap> SA6 := Subalgebra( A6, [ eA6[1], eA6[2], eA6[3] ] );
<algebra over GF(2), with 3 generators>
gap> [ Size(A6), Size(SA6) ];
[ 64, 4 ]
gap> SB6 := Subalgebra( B6, [ eB6[1], eB6[2] ] );
<algebra over GF(2), with 2 generators>
gap> [ Size(B6), Size(SB6) ];
[ 8, 2 ]
gap> SC6 := SubCat1Algebra( C6, SA6, SB6 );
[Algebra( GF(2), [ <zero> of ..., (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(4,5)
] ) -> Algebra( GF(2), [ <zero> of ..., (Z(2)^0)*() ] )]
gap> Display( SC6 );
Cat1-algebra [..=>..] :-
: source algebra has generators:
  [ <zero> of ..., (Z(2)^0)*(), (Z(2)^0)*()+(Z(2)^0)*(4,5) ]
:  range algebra has generators:
  [ <zero> of ..., (Z(2)^0)*() ]
: tail homomorphism maps source generators to:
  [ <zero> of ..., (Z(2)^0)*(), <zero> of ... ]
: head homomorphism maps source generators to:
  [ <zero> of ..., (Z(2)^0)*(), <zero> of ... ]
: range embedding maps range generators to:
  [ <zero> of ..., (Z(2)^0)*() ]
: kernel has generators:
  [ <zero> of ..., (Z(2)^0)*()+(Z(2)^0)*(4,5) ]
: boundary homomorphism maps generators of kernel to:
  [ <zero> of ..., <zero> of ... ]
: kernel embedding maps generators of kernel to:
  [ <zero> of ..., (Z(2)^0)*()+(Z(2)^0)*(4,5) ]
gap> IsSubCat1Algebra( C6, SC6 );
true
]]>
</Example>

</Section>

<Section>

<Heading>Cat<M>^{1}-</M>algebra morphisms</Heading>

Let <M>\mathcal{C} = (e;t,h:A\rightarrow R)</M>,
<M>\mathcal{C}^{\prime } = (e^{\prime}; t^{\prime }, h^{\prime }
                           : A^{\prime} \rightarrow R^{\prime})</M>
be cat<M>^{1}</M>-algebras,
and let <M>\phi : A\rightarrow A^{\prime}</M>
and <M>\varphi : R \rightarrow R^{\prime}</M> be algebra homomorphisms.
If the diagram
<Display>
\xymatrix@R=50pt@C=50pt{ A \ar@{->}@<-1.5pt>[d]_{t}
\ar@{->}@<1.5pt>[d]^{h} \ar@{->}[r]^{\phi} & A' \ar@{->}@<-1.5pt>[d]_{t'}
\ar@{->}@<1.5pt>[d]^{h'} \\ R \ar@/^1.5pc/[u]^{e} \ar@{->}[r]_{\varphi} & R' \ar@/_1.5pc/[u]_{e'}
}
</Display>
commutes, (i.e. <M>t^{\prime} \circ \phi = \varphi \circ t</M>,
<M>h^{\prime} \circ \phi = \varphi \circ h</M> and
<M>e^{\prime } \circ \varphi = \phi \circ e</M>),
then the pair <M>(\phi ,\varphi )</M> is called
a cat<M>^{1}</M>-algebra morphism.

<ManSection>
   <Func Name="Cat1AlgebraMorphism"
         Arg="arg" />
   <Func Name="PreCat1AlgebraMorphism"
         Arg="arg" />
   <Meth Name="IdentityMapping" Label="for cat1-algebras"
         Arg="C" />
   <Oper Name="PreCat1AlgebraMorphismByHoms"
         Arg="src rng srchom rnghom" />
   <Oper Name="Cat1AlgebraMorphismByHoms"
         Arg="src rng srchom rnghom" />
   <Prop Name="IsPreCat1AlgebraMorphism"
         Arg="mor" />
   <Prop Name="IsCat1AlgebraMorphism"
         Arg="mor" />
<Description>
These operations are used for constructing cat<M>^{1}</M>-algebra morphisms.
Details of the implementations can be found in <Cite Key="aodabas1"/>.
</Description>
</ManSection>

<ManSection>
   <Attr Name="Source" Label="for morphisms of cat1-algebras"
         Arg="m" />
   <Attr Name="Range" Label="for morphisms of cat1-algebras"
         Arg="m" />
   <Meth Name="IsTotal" Label="for morphisms of cat1-algebras"
         Arg="m" />
   <Meth Name="IsSingleValued" Label="for morphisms of cat1-algebras"
         Arg="m" />
   <Meth Name="Name" Label="for morphisms of cat1-algebras"
         Arg="m" />
   <Attr Name="Boundary" Label="for morphisms of cat1-algebras"
         Arg="m" />
<Description>
These are the six main attributes of a cat<M>^{1}</M>-algebra morphism.
</Description>
</ManSection>

<Example>
<![CDATA[
gap> C1 := Cat1AlgebraSelect( 2, 1, 1, 1 );
[GF(2)_triv -> GF(2)_triv]
gap> Display( C1 );
Cat1-algebra [GF(2)_triv=>GF(2)_triv] :-
: source algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
:  range algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: tail homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: head homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: range embedding maps range generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: the kernel is trivial.
gap> C2 := Cat1AlgebraSelect( 2, 2, 1, 2 );
[GF(2)_c2 -> GF(2)_triv]
gap> Display( C2 );
Cat1-algebra [GF(2)_c2=>GF(2)_triv] :-
: source algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*(1,2) ]
:  range algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: tail homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: head homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: range embedding maps range generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: kernel has generators:
  [ (Z(2)^0)*()+(Z(2)^0)*(1,2) ]
: boundary homomorphism maps generators of kernel to:
  [ <zero> of ... ]
: kernel embedding maps generators of kernel to:
  [ (Z(2)^0)*()+(Z(2)^0)*(1,2) ]
gap> C1 = C2;
false
gap> SC1 := Source( C1 );;
gap> SC2 := Source( C2 );
GF(2)_c2
gap> RC1 := Range( C1 );;
gap> RC2 := Range( C2 );;
gap> gSC1 := GeneratorsOfAlgebra( SC1 );
[ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> gSC2 := GeneratorsOfAlgebra( SC2 );
[ (Z(2)^0)*(), (Z(2)^0)*(1,2) ]
gap> gRC1 := GeneratorsOfAlgebra( RC1 );
[ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> gRC2 := GeneratorsOfAlgebra( RC2 );
[ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> imS := [ gSC2[1], gSC2[1] ];
[ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> homS := AlgebraHomomorphismByImages( SC1, SC2, gSC1, imS );
[ (Z(2)^0)*(), (Z(2)^0)*() ] -> [ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> imR := [ gRC2[1], gRC2[1] ];
[ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> homR := AlgebraHomomorphismByImages( RC1, RC2, gRC1, imR );
[ (Z(2)^0)*(), (Z(2)^0)*() ] -> [ (Z(2)^0)*(), (Z(2)^0)*() ]
gap> m12 := Cat1AlgebraMorphism( C1, C2, homS, homR );
[[GF(2)_triv=>GF(2)_triv] => [GF(2)_c2=>GF(2)_triv]]
gap> Display( m12 );

Morphism of cat1-algebras :-
: Source = [GF(2)_triv=>GF(2)_triv] with generating sets:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
:  Range = [GF(2)_c2=>GF(2)_triv] with generating sets:
  [ (Z(2)^0)*(), (Z(2)^0)*(1,2) ]
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: Source Homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: Range Homomorphism maps range generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]

## gap> Image2dAlgMapping( m12 );
## [GF(3)_c2^3=>GF(3)_c2^3]
gap> IsSurjective( m12 );
false
gap> IsInjective( m12 );
true
gap> IsBijective( m12 );
false
]]>
</Example>

<ManSection>
   <Oper Name="ImagesSource2DimensionalMapping"
         Arg="m" />
<Description>
When <M>(\theta,\varphi)</M> is a homomorphism of cat1-algebras
(or crossed modules)
this operation returns the image crossed module.
</Description>
</ManSection>

<Example>
<![CDATA[
gap> im12 := ImagesSource2DimensionalMapping( m12 );;
gap> Display( im12 );
Cat1-algebra [..=>..] :-
: source algebra has generators:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
:  range algebra has generators:
  [ (Z(2)^0)*() ]
: tail homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: head homomorphism maps source generators to:
  [ (Z(2)^0)*(), (Z(2)^0)*() ]
: range embedding maps range generators to:
  [ (Z(2)^0)*() ]
: the kernel is trivial.
]]>
</Example>

</Section>

</Chapter>

quality90%

¤ Dauer der Verarbeitung: 0.2 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.