> < ^ Date: Fri, 01 Sep 1995 12:32:00 +1553
> < ^ From: Alexander Hulpke <hulpke@math.colostate.edu >
^ Subject: Bug in Kernel computation

Dear GAP-Forum,

The homomorphism routines for AgGroups contain an error that occurs when
computing the (nontrivial) kernel of an homomorphism into an AgGroup:

```gap> g:=SymmetricGroup(3);;
gap> h:=TrivialSubgroup(SolvableGroup(2,1));;
gap> hom:=GroupHomomorphismByImages(g,h,g.generators,
List(g.generators,i->h.identity));;
GroupHomomorphismByImages( Group( (1,3), (2,3) ), Subgroup( c2, [  ] ),
[ (1,3), (2,3) ], [ IdAgWord, IdAgWord ] )
gap> Kernel(hom);
Subgroup( Group( (1,3), (2,3) ), [  ] )
```

Reason for this error is a bad trick the `Kernel` routine plays on
`GroupHomomorphismByImages`: The inverse Mapping is constructed which is not
a true Homomorphism but only used for intermediate computations. This
mapping however is mangled by the AgGroup routines when trying to compute
a Cgs for the source subgroup.
Replacing the routine `AgGroupOps.GroupHomomorphismByImages` in the library
file `aghomom.g` by the following code bypasses the error:

```#############################################################################
##
#F  AgGroupOps.GroupHomomorphismByImages( <U>, <R>, <g>, <i> ) . . create hom
##
AgGroupOps.GroupHomomorphismByImages := function( D, R, gens, imgs )
```
```local   h,      # homomorphism
i,
ogens,
oimgs,
tmp;    # temporary

# Normalize <gens> and unbind possible '<D>.field'.
ogens := gens;
oimgs := imgs;
D := Normalized( D );
Unbind( D.field );
if Cgs(D) <> gens  then
tmp  := AbstractIgs( D, gens, imgs );
gens := tmp.igs;
imgs := tmp.abstractIgs;
fi;

# If range <R> is just 'rec()', try to construct the image.
if not IsBound( R.generators )  then
if 0 = Length(imgs)  then
Error( "needs either range or at least one image" );
fi;
R := Group( imgs, imgs[1]^0 );
fi;

# Construct the homorphism record.
h := rec( source           := D,
range            := R,
domain           := Mappings,
generators       := gens,
genimages        := imgs,
preimage         := D,
image            := R.operations.Subgroup( Parent(R), imgs ),
isGeneralMapping := true,
operations       := AgGroupHomomorphismByImagesOps );

# check at least the given generator images <oimgs>
if not IsFpGroup(R)  then
for i  in [ 1 .. Length(ogens) ]  do
if Image( h, ogens[i] ) <> oimgs[i]  then
return GroupOps.GroupHomomorphismByImages(D,R,ogens,oimgs);
fi;
od;
fi;
return h;
```

end;
AgGroupHomomorphismByImagesOps.Kernel :=
AgGroupHomomorphismByImagesOps.KernelGroupHomomorphism;

I apologize for any inconvenience this error might have caused.

Alexander Hulpke

> < [top]