diff --git a/PackageInfo.g b/PackageInfo.g
index 47cb4ee..cc79352 100644
--- a/PackageInfo.g
+++ b/PackageInfo.g
@@ -8,8 +8,8 @@ SetPackageInfo( rec(
 
 PackageName := "XModAlg",
 Subtitle := "Crossed Modules and Cat1-Algebras",
-Version := "1.25",
-Date := "17/05/2024", # dd/mm/yyyy format
+Version := "1.25dev",
+Date := "14/06/2024", # dd/mm/yyyy format
 License := "GPL-2.0-or-later",
 
 Persons := [
diff --git a/doc/xmod.xml b/doc/xmod.xml
index 40e7746..0377c2e 100644
--- a/doc/xmod.xml
+++ b/doc/xmod.xml
@@ -2,7 +2,7 @@
 <!--                                                                     -->
 <!--  xmod.xml            XModAlg documentation               Z. Arvasi  -->
 <!--                                                        & A. Odabas  -->
-<!--  Copyright (C) 2014-2022, Z. Arvasi & A. Odabas,                    --> 
+<!--  Copyright (C) 2014-2024, Z. Arvasi & A. Odabas,                    --> 
 <!--  Osmangazi University, Eskisehir, Turkey                            --> 
 <!--                                                                     -->
 <!-- ------------------------------------------------------------------- -->
@@ -238,24 +238,7 @@ Crossed module [<e5>->GF(2^2)[k4]] :-
 ]]>
 </Example>
 
-<ManSection>
-   <Oper Name="XModAlgebraByModule"
-         Arg="M R" />
-<Description> 
-Let <M>M</M> be a <M>R</M>-module.  
-Then <M>\mathcal{X} = (0:M\rightarrow R)</M> is a crossed module. 
-Conversely, given a crossed module 
-<M>\mathcal{X} = (\partial :M\rightarrow R)</M>,
-one can get that <M>\ker\partial</M> is a <M>(R/\partial M)</M>-module.
-<P/>
-</Description>
-</ManSection>
-
-<Example>
-<![CDATA[
-gap> ## example needed 
-]]>
-</Example>
+<#Include Label="XModAlgebraByModule">
 
 <ManSection>
    <Attr Name="Source" Label="for crossed modules of commutative algebras"
diff --git a/examples/module.g b/examples/module.g
deleted file mode 100644
index e786c23..0000000
--- a/examples/module.g
+++ /dev/null
@@ -1,63 +0,0 @@
-############################################################################
-##
-#W  module.g             XModAlg example files                 Chris Wensley 
-## 
-
-LoadPackage( "xmodalg" );
-
-## Chapter 2, Section 2.2.3
-A := Rationals^[3,3];;
-SetName( A, "Q[3,3]" );;
-V := Rationals^3;;
-M := LeftAlgebraModule( A, \*, V );
-SetName( M, "M" );
-famM := ElementsFamily( FamilyObj( M ) );;
-v := [3,4,5];;
-v2 := ObjByExtRep( famM, v );
-Print( "v = ", v, ",  v2 = ", v2, "\n" );
-m := [ [0,1,0], [0,0,1], [1,0,0] ];;
-Print( "m = ", m, "\n" );
-Print( "m*v2 = ", m*v2, "\n" );
-genM := GeneratorsOfLeftModule( M );;
-u2 := 6*genM[1] + 7*genM[2] + 8*genM[3];
-u := ExtRepOfObj( u2 );
-Print( "u2 = ", u2, ",  u = ", u, "\n" );
-
-## Chapter 2, Section 2.2.4
-D := LeftActingDomain( M );;
-T := EmptySCTable( Dimension(M), Zero(D), "symmetric" );;
-B1 := AlgebraByStructureConstants( D, T );
-Print( "B1 = ", B1, "\n" );
-Print( "B1 has generators: ", GeneratorsOfAlgebra( B1 ), "\n" );
-B := ModuleAsAlgebra( M );             
-Print( "B has name: ", B, "\n" );
-Print( "B has generators: ", GeneratorsOfAlgebra( B ), "\n" );
-
-## Chapter 2, Section 2.2.5
-Print( "IsModuleAsAlgebra( B )? ", IsModuleAsAlgebra( B ), "\n" );
-Print( "IsModuleAsAlgebra( A )? ", IsModuleAsAlgebra( A ), "\n" );
-
-## Chapter 2, Section 2.2.6
-Print( "the known attributes of B are:\n" );
-Print( KnownAttributesOfObject( B ), "\n" );
-M2B := ModuleToAlgebraIsomorphism( B );
-Print( "M2B = ", M2B, "\n" );
-Print( "Source( M2B ) = M? ", Source( M2B ) = M, "\n" );
-Print( "Source( M2B ) = V? ", Source( M2B ) = V, "\n" );
-B2M := AlgebraToModuleIsomorphism( B );
-Print( "B2M = ", B2M, "\n" );
-Print( "Range( B2M ) = M? ", Range( B2M ) = M, "\n" );
-Print( "Range( B2M ) = V? ", Range( B2M ) = V, "\n" );
-
-## Chapter 2, Section 2.2.7
-act := AlgebraActionByModule( A, M );
-Print( "the action act of A on B is:\n", act, "\n" );
-genA := GeneratorsOfAlgebra(A);;
-m := 5*genA[1] - 4*genA[2] + 3*genA[3];
-Print( "m = ", m, ":\n" );
-Print( "the image of m under act is: ", Image( act, m ), "\n" );
-Print( "the image of the action act is:\n", Image(act ), "\n" );
-
-############################################################################
-##
-#E  module.g  . . . . . . . . . . . . . . . . . . . . . . . . . . ends here
\ No newline at end of file
diff --git a/examples/module3.g b/examples/module3.g
new file mode 100644
index 0000000..c40554a
--- /dev/null
+++ b/examples/module3.g
@@ -0,0 +1,70 @@
+############################################################################
+##
+#W  module3.g            XModAlg example files                 Chris Wensley 
+## 
+
+LoadPackage( "xmodalg" );
+
+## Chapter 2, Section 2.2.3
+m := [ [0,1,0], [0,0,1], [1,0,0] ];
+Print( "m = ", m, "\n" );
+A3 := Algebra( Rationals, [m] );
+SetName( A3, "A3" );;
+V3 := Rationals^3;;
+M3 := LeftAlgebraModule( A3, \*, V3 );
+SetName( M3, "M3" );
+famM3 := ElementsFamily( FamilyObj( M3 ) );;
+v := [3,4,5];;
+v2 := ObjByExtRep( famM3, v );
+Print( "v = ", v, ",  v2 = ", v2, "\n" );
+Print( "m*v2 = ", m*v2, "\n" );
+genM3 := GeneratorsOfLeftModule( M3 );;
+u2 := 6*genM3[1] + 7*genM3[2] + 8*genM3[3];
+u := ExtRepOfObj( u2 );
+Print( "u2 = ", u2, ",  u = ", u, "\n" );
+
+## Chapter 2, Section 2.2.4
+D3 := LeftActingDomain( M3 );;
+T3 := EmptySCTable( Dimension(M3), Zero(D3), "symmetric" );;
+B3a := AlgebraByStructureConstants( D3, T3 );
+Print( "B3a = ", B3a, "\n" );
+Print( "B3a has generators: ", GeneratorsOfAlgebra( B3a ), "\n" );
+B3 := ModuleAsAlgebra( M3 );             
+Print( "B3 has name: ", Name( B3 ), "\n" );
+Print( "B3 has generators: ", GeneratorsOfAlgebra( B3 ), "\n" );
+
+## Chapter 2, Section 2.2.5
+Print( "IsModuleAsAlgebra( B3 )? ", IsModuleAsAlgebra( B3 ), "\n" );
+Print( "IsModuleAsAlgebra( A3 )? ", IsModuleAsAlgebra( A3 ), "\n" );
+
+## Chapter 2, Section 2.2.6
+Print( "the known attributes of B3 are:\n" );
+Print( KnownAttributesOfObject( B3 ), "\n" );
+M2B3 := ModuleToAlgebraIsomorphism( B3 );
+Print( "M2B3 = ", M2B3, "\n" );
+Print( "Source( M2B3 ) = M3? ", Source( M2B3 ) = M3, "\n" );
+Print( "Source( M2B3 ) = V3? ", Source( M2B3 ) = V3, "\n" );
+B2M3 := AlgebraToModuleIsomorphism( B3 );
+Print( "B2M3 = ", B2M3, "\n" );
+Print( "Range( B2M3 ) = M3? ", Range( B2M3 ) = M3, "\n" );
+Print( "Range( B2M3 ) = V3? ", Range( B2M3 ) = V3, "\n" );
+
+## Chapter 2, Section 2.2.7
+act3 := AlgebraActionByModule( A3, M3 );
+Print( "the action act3 of A3 on B3 is:\n", act3, "\n" );
+genA3 := GeneratorsOfAlgebra( A3 );;
+a := 2*m + 3*m^2;
+Print( "a = ", a, ":\n" );
+Print( "the image of a under act3 is:\n", Image( act3, a ), "\n" );
+Print( "the image of the action act3 is:\n", Image( act3 ), "\n" );
+Print( "\n" );
+
+## Chapter 4, Section 4.1.7
+X3 := XModAlgebraByModule( A3, M3 );
+Print( "Name( X3 ) = ", Name( X3 ), "\n" );
+Display( X3 );
+
+
+############################################################################
+##
+#E  module3.g . . . . . . . . . . . . . . . . . . . . . . . . . . ends here
\ No newline at end of file
diff --git a/lib/alg2obj.gd b/lib/alg2obj.gd
index 059a2d4..bf9b0cb 100644
--- a/lib/alg2obj.gd
+++ b/lib/alg2obj.gd
@@ -44,8 +44,6 @@ DeclareOperation( "XModAlgebraByBoundaryAndAction",
 DeclareOperation( "XModAlgebraBySurjection", [ IsAlgebraHomomorphism ] );
 DeclareOperation( "XModAlgebraByMultiplierAlgebra", 
     [ IsAlgebra ] );
-DeclareOperation( "XModAlgebraByModule", 
-    [ IsAlgebra, IsRing ] );
 DeclareOperation( "XModAlgebraByIdeal", 
     [ IsAlgebra, IsAlgebra ] ); 
 DeclareAttribute( "AugmentationXMod", IsGroupAlgebra ); 
diff --git a/lib/alg2obj.gi b/lib/alg2obj.gi
index 6131585..c61fde8 100644
--- a/lib/alg2obj.gi
+++ b/lib/alg2obj.gi
@@ -1,7 +1,7 @@
-#############################################################################
+############################################################################
 ##
-#W  alg2obj.gi                 The XMODALG package            Zekeriya Arvasi
-#W                                                             & Alper Odabas
+#W  alg2obj.gi                 The XMODALG package           Zekeriya Arvasi
+#W                                                            & Alper Odabas
 #Y  Copyright (C) 2014-2022, Zekeriya Arvasi & Alper Odabas,  
 ##
     
@@ -16,9 +16,9 @@ CAT1ALG_LIST_CLASS_SIZES :=
 CAT1ALG_LIST_LOADED := false;
 CAT1ALG_LIST := [ ];
 
-##############################  2d-algebras  ################################ 
+##############################  2d-algebras  ############################### 
 
-#############################################################################
+############################################################################
 ##
 #M  Is2dAlgebraObject
 ##
@@ -29,7 +29,7 @@ CAT1ALG_LIST := [ ];
 ##      return ( HasSource( obj ) and HasRange( obj ) );
 ##  end );
 
-##############################################################################
+############################################################################
 ##
 #M  Sub2dAlgebra               
 ##
@@ -50,11 +50,11 @@ function( obj, src, rng )
 end );
 
 
-#########################  (pre-)crossed modules  ########################### 
+#########################  (pre-)crossed modules  ######################### 
 
-#############################################################################
+###########################################################################
 ##
-#M  IsPreXModAlgebra          check that the first crossed module axiom holds
+#M  IsPreXModAlgebra        check that the first crossed module axiom holds
 ##
 InstallMethod( IsPreXModAlgebra, "generic method for pre-crossed modules",
     true, [ Is2dAlgebra ], 0,
@@ -98,9 +98,9 @@ function( P )
     return true;
 end );
 
-##############################################################################
+###########################################################################
 ##
-#M  XModAlgebraObj( <bdy>, <act> ) . . . . . . . . . . make pre-crossed module
+#M  XModAlgebraObj( <bdy>, <act> )  . . . . . . . make a pre-crossed module
 ##
 InstallMethod( XModAlgebraObj, "for homomorphism and action", true,
     [ IsAlgebraHomomorphism, IsAlgebraAction ], 0,
@@ -140,9 +140,9 @@ function( bdy, act )
     return PM;
 end );
 
-##############################################################################
+############################################################################
 ##
-#M  \=( <P>, <Q> )  . . . . . . . .  test if two pre-crossed modules are equal
+#M  \=( <P>, <Q> )  . . . . . . .  test if two pre-crossed modules are equal
 ##
 InstallMethod( \=, "generic method for two pre-crossed modules of algebras",
     IsIdenticalObj, [ IsPreXModAlgebra, IsPreXModAlgebra ], 0,
@@ -187,9 +187,9 @@ function ( P, Q )
     return true;
 end );
 
-#############################################################################
+############################################################################
 ##
-#M  ViewObj( <PM> ) . . . . . . . . . . . . . . . view a (pre-)crossed module
+#M  ViewObj( <PM> ) . . . . . . . . . . . . . .  view a (pre-)crossed module
 ##
 InstallMethod( ViewObj, "method for a pre-crossed module of algebras", true,
     [ IsPreXModAlgebra ], 0,
@@ -232,9 +232,9 @@ InstallMethod( ViewObj, "method for a pre-crossed module of algebras", true,
     fi;
 end );
 
-#############################################################################
+############################################################################
 ##
-#M  PrintObj( <PM> )  . . . . . . . . . . . . . . view a (pre-)crossed module
+#M  PrintObj( <PM> ) . . . . . . . . . . . . . . view a (pre-)crossed module
 ##
 InstallMethod( PrintObj, "method for a pre-crossed algebra module", true,
     [ IsPreXModAlgebra ], 0,
@@ -246,9 +246,9 @@ InstallMethod( PrintObj, "method for a pre-crossed algebra module", true,
     fi;
 end );
 
-#############################################################################
+############################################################################
 ##
-#F  Display( <PM> ) . . . . . . . . . print details of a (pre-)crossed module
+#F  Display( <PM> ) . . . . . . . .  print details of a (pre-)crossed module
 ##
 InstallOtherMethod( Display, "display a pre-crossed module of algebras", 
     true, [IsPreXModAlgebra], 0,
@@ -304,9 +304,9 @@ function( PM )
     fi;
 end ); 
 
-#############################################################################
+############################################################################
 ##
-#M  Name                                                for a pre-XModAlgebra
+#M  Name                                               for a pre-XModAlgebra
 ##
 InstallMethod( Name, "method for a pre-crossed module", true, 
     [ IsPreXModAlgebra ], 0,
@@ -329,7 +329,7 @@ function( PM )
     return name;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  Dimension( <PM> )  . . . . . . . . . dimension of a (pre-)crossed module
 ##
@@ -339,9 +339,9 @@ InstallMethod( Dimension, "method for a pre-crossed algebra module", true,
     return [ Dimension( Source( PM ) ), Dimension( Range( PM ) ) ]; 
 end );
 
-#############################################################################
+############################################################################
 ##
-#M  IsXModAlgebra            check that the second crossed module axiom holds
+#M  IsXModAlgebra           check that the second crossed module axiom holds
 ##
 InstallMethod( IsXModAlgebra, "generic method for pre-crossed modules",
     true, [ Is2dAlgebra ], 0,
@@ -371,7 +371,7 @@ InstallMethod( IsXModAlgebra, "generic method for pre-crossed modules",
     return true;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  PreXModAlgebraByBoundaryAndAction
 ##
@@ -400,7 +400,7 @@ function( bdy, act )
     return obj;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  XModAlgebraByBoundaryAndAction
 ##
@@ -418,7 +418,7 @@ function( bdy, act )
     return PM;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  XModAlgebraByMultiplierAlgebra
 ##
@@ -439,7 +439,7 @@ function( A )
     return PM;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  XModAlgebraBySurjection
 ##
@@ -458,27 +458,7 @@ function( hom )
     return PM;
 end );
 
-#############################################################################
-##
-#M  XModAlgebraByModule
-##
-InstallMethod( XModAlgebraByModule, "crossed module from module", true,
-    [ IsAlgebra, IsRing ], 0,
-function( M,R )
-    local  PM,act,bdy;
-    #M := GroupRing(R,G);
-    act := AlgebraAction(M,R);
-    bdy := ModuleHomomorphism(M,R);
-    SetIsAlgebraAction( act, true );
-    IsAlgebraHomomorphism(bdy);
-    PM := PreXModAlgebraByBoundaryAndAction( bdy, act );
-    if not IsXModAlgebra( PM ) then
-        Error( "this boundary and action only defines a pre-crossed module" );
-    fi;
-    return PM;
-end );
-
-#############################################################################
+############################################################################
 ##
 #M  XModAlgebraByIdeal
 ##
@@ -501,7 +481,7 @@ function( A, I )
     return PM;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  AugmentationXMod
 ##
@@ -513,7 +493,7 @@ function( A )
     return XModAlgebraByIdeal( A, AI ); 
 end );
 
-#############################################################################
+############################################################################
 ##
 #F  XModAlgebra( <bdy>, <act> )   crossed module from given boundary & action
 ##
@@ -526,9 +506,9 @@ InstallGlobalFunction( XModAlgebra, function( arg )
                        and IsAlgebraAction( arg[2] ) ) then
         return XModAlgebraByBoundaryAndAction( arg[1], arg[2] );
     # module
-    elif ( ( nargs = 2 ) and IsRing( arg[1] )
-                       and IsGroup( arg[2] ) ) then 
-        return XModAlgebraByModule( GroupRing( arg[1],arg[2] ),arg[1] );
+    elif ( ( nargs = 2 ) and IsAlgebra( arg[1] )
+                         and IsLeftModule( arg[2] ) ) then 
+        return XModAlgebraByModule( arg[1], arg[2] );
     # ideal
     elif ( ( nargs = 2 ) and IsAlgebra( arg[1] )
             and IsAlgebra( arg[2] ) and IsIdeal(arg[1],arg[2]) ) then 
@@ -548,7 +528,7 @@ InstallGlobalFunction( XModAlgebra, function( arg )
     Error( "usage: XModAlgebra( bdy, act ); " );
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  IsSubPreXModAlgebra
 ##
@@ -658,7 +638,7 @@ function( PM, SM )
     return true;
 end );
 
-##############################################################################
+###########################################################################
 ##
 #M  IsSubXModAlgebra( <XM>, <SM> )
 ##
@@ -672,7 +652,7 @@ function( XM, SM )
     return IsSubPreXModAlgebra( XM, SM );
 end );
 
-##############################################################################
+###########################################################################
 ##
 #M  SubPreXModAlgebra            creates SubPreXMod Of Algebra from Ssrc<=Psrc 
 ##
@@ -733,7 +713,7 @@ function( PM, Ssrc, Srng )
     return SM;
 end );
 
-##############################################################################
+###########################################################################
 ##
 #M  SubXModAlgebra . . . . creates SubXModAlgebra from Ssrc<=Psrc & Srng<=Prng
 ##
@@ -754,11 +734,11 @@ end );
 
 
 
-#############################  cat1-algebras  ############################### 
+#############################  cat1-algebras  ############################## 
 
-#############################################################################
+############################################################################
 ##
-#M  IsPreCat1Algebra        check that the first pre-cat1-algebra axiom holds
+#M  IsPreCat1Algebra       check that the first pre-cat1-algebra axiom holds
 ##
 InstallMethod( IsPreCat1Algebra, "generic method for pre-cat1-algebra",
     true, [ Is2dAlgebra ], 0,
@@ -788,7 +768,7 @@ function( C1A )
     return true;
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  IsSubPreCat1Algebra
 ##
@@ -843,7 +823,7 @@ function( C0, S0 )
     return true;
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  IsSubCat1Algebra( <C1>, <S1> )
 ##
@@ -857,9 +837,9 @@ function( C1, S1 )
     return IsSubPreCat1Algebra( C1, S1 );
 end );
 
-###############################################################################
+############################################################################
 ##
-#M  SubPreCat1 . . creates SubPreCat1 from PreCat1 and a subgroup of the source
+#M  SubPreCat1  creates SubPreCat1 from PreCat1 and a subgroup of the source
 ##
 InstallMethod( SubPreCat1Algebra, "generic method for (pre-)cat1-algebras", 
     true, [ IsPreCat1Algebra, IsAlgebra, IsAlgebra ], 0,
@@ -888,7 +868,7 @@ function( C, R, S )
     return CC;
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  SubCat1Algebra . . . . . . creates SubCat1Algebra from Cat1Algebra 
 ##                             and a subalgebra of the source
@@ -904,9 +884,9 @@ function( C, R, S )
     return CC;
 end );
 
-##############################################################################
+############################################################################
 ##
-#M  \=( <C1>, <C2> ) . . . . . . . . . test if two pre-cat1-algebras are equal
+#M  \=( <C1>, <C2> ) . . . . . . . . . . . test if two pre-cat1-algebras are equal
 ##
 InstallMethod( \=, "generic method for pre-cat1-algebras",
     IsIdenticalObj, [ IsPreCat1Algebra, IsPreCat1Algebra ], 0,
@@ -916,9 +896,9 @@ InstallMethod( \=, "generic method for pre-cat1-algebras",
              and ( RangeEmbedding( C1 ) = RangeEmbedding( C2 ) ) );
 end );
 
-##############################################################################
+############################################################################
 ##
-#M  PreCat1AlgebraObj . . . . . . . . . . . . . . . . make a pre-cat1-algebra
+#M  PreCat1AlgebraObj . . . . . . . . . . . . . . .  make a pre-cat1-algebra
 ##
 InstallMethod( PreCat1AlgebraObj, "for tail, head, embedding", true,
     [ IsAlgebraHomomorphism, IsAlgebraHomomorphism, IsAlgebraHomomorphism ], 0,
@@ -954,9 +934,9 @@ InstallMethod( PreCat1AlgebraObj, "for tail, head, embedding", true,
     return C1A;
 end );
 
-##############################################################################
+############################################################################
 ##
-#M  ViewObj( <C1A> ) . . . . . . . . . . . . . . . . . view a pre-cat1-algebra
+#M  ViewObj( <C1A> ) . . . . . . . . . . . . . . . . view a pre-cat1-algebra
 ##
 InstallMethod( ViewObj, "method for a pre-cat1-algebra", true, 
     [ IsPreCat1Algebra ], 0,
@@ -1002,9 +982,9 @@ function( C1A )
     fi;
 end );
 
-##############################################################################
+############################################################################
 ##
-#M  PrintObj( <C1A> )  . . . . . . . . . . . . . . view a (pre-)crossed module
+#M  PrintObj( <C1A> )  . . . . . . . . . . . . . view a (pre-)crossed module
 ##
 InstallMethod( PrintObj, "method for a pre-cat1-algebra", true,
     [ IsPreCat1Algebra ], 0,
@@ -1016,7 +996,7 @@ function( C1A )
     fi;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  Display( <C1A> ) . . . . . . . . . . print details of a pre-cat1-algebra
 ##
@@ -1100,9 +1080,9 @@ function( C1A )
     Print( "\n" );
 end );
 
-#############################################################################
+############################################################################
 ##
-#M  Name                                               for a pre-cat1-alegbra
+#M  Name                                              for a pre-cat1-alegbra
 ##
 InstallMethod( Name, "method for a pre-cat1-algebra", true, 
     [ IsPreCat1Algebra ], 0,
@@ -1125,10 +1105,10 @@ function( C1A )
     return name;
 end );
 
-#############################################################################
+############################################################################
 ##
-#F  PreCat1Algebra( <t>, <h>, <e> )   pre-cat1-algebra from tail, head, embed
-#F  PreCat1Algebra( <t>, <h> )        pre-cat1-algebra from tail, head endos
+#F  PreCat1Algebra( <t>, <h>, <e> )  pre-cat1-algebra from tail, head, embed
+#F  PreCat1Algebra( <t>, <h> )       pre-cat1-algebra from tail, head, endos
 ##
 InstallGlobalFunction( PreCat1Algebra, function( arg )
 
@@ -1148,9 +1128,9 @@ InstallGlobalFunction( PreCat1Algebra, function( arg )
     Error( "standard usage: PreCat1Algebra( tail, head [,embedding] );" );
 end );
 
-#############################################################################
+############################################################################
 ##
-#M  IsCat1Algebra              check that the second cat1-algebra axiom holds
+#M  IsCat1Algebra             check that the second cat1-algebra axiom holds
 ##
 InstallMethod( IsCat1Algebra, "generic method for crossed modules",
     true, [ Is2dAlgebra ], 0,
@@ -1199,7 +1179,7 @@ function( C1A )
     return true;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  IsIdentityCat1Algebra
 ##
@@ -1210,12 +1190,12 @@ function( C1A )
              ( TailMap( C1A ) = IdentityMapping( Source( C1A ) ) ) );
 end );
 
-#############################################################################
+############################################################################
 ##
 #F  Cat1Algebra( <GF(n)>,<size>, <gpnum>, <num> )   
-##                                    cat1-algebra from data in CAT1_ALG_LIST
-#F  Cat1Algebra( <t>, <h>, <e> )      cat1-algebra from tail, head, embed
-#F  Cat1Algebra( <t>, <h> )           cat1-algebra from tail, head endos
+##                                   cat1-algebra from data in CAT1_ALG_LIST
+#F  Cat1Algebra( <t>, <h>, <e> )     cat1-algebra from tail, head, embed
+#F  Cat1Algebra( <t>, <h> )          cat1-algebra from tail, head endos
 ##
 InstallGlobalFunction( Cat1Algebra, 
 function( arg )
@@ -1254,10 +1234,10 @@ function( arg )
     fi;
 end );
 
-#############################################################################
+############################################################################
 ##
 #F  Cat1AlgebraSelect( <size>, <gpnum>, <num> )   
-##                                        cat1-algebra from data in CAT1_LIST
+##                                       cat1-algebra from data in CAT1_LIST
 ##
 InstallOtherMethod( Cat1AlgebraSelect, 
     "construct a cat1-algebra using data in file", true, [ IsInt ], 0,
@@ -1429,13 +1409,14 @@ function( gf, size, gpnum, num )
     return PreCat1AlgebraByEndomorphisms( t, h );
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  PreCat1AlgebraByTailHeadEmbedding
 ##
 InstallMethod( PreCat1AlgebraByTailHeadEmbedding,
     "cat1-algebra from tail, head and embedding", true, 
-    [ IsAlgebraHomomorphism, IsAlgebraHomomorphism, IsAlgebraHomomorphism ], 0,
+    [ IsAlgebraHomomorphism, IsAlgebraHomomorphism, IsAlgebraHomomorphism ],
+    0,
 function( t, h, e )
 
     local  genG, R, genR, imh, imt, ime, eR, hres, tres, eres,
@@ -1472,7 +1453,7 @@ function( t, h, e )
     return PC;
 end );
 
-#############################################################################
+############################################################################
 ##
 #M  PreCat1AlgebraByEndomorphisms( <et>, <eh> )
 ##
@@ -1510,47 +1491,47 @@ function( et, eh )
     return A; 
 end );
 
-#############################################################################
+############################################################################
 ##
-#M  Source( C1A ) . . . . . . . . . . . . . . . . . . . .  for a cat1-algebra
+#M  Source( C1A ) . . . . . . . . . . . . . . . . . . . . for a cat1-algebra
 ##
 InstallOtherMethod( Source, "method for a pre-cat1-algebra", true,
     [ IsPreCat1Algebra ], 0,
     C1A -> Source( TailMap( C1A ) ) );
 
-##############################################################################
+############################################################################
 ##
-#M  Range( C1A ) . . . . . . . . . . . . . . . . . . . . . for a cat1-algebra
+#M  Range( C1A ) . . . . . . . . . . . . . . . . . . . .  for a cat1-algebra
 ##
 InstallOtherMethod( Range, "method for a pre-cat1-algebra", true,
     [ IsPreCat1Algebra ], 0,
     C1A -> Range( TailMap( C1A ) ) );
 
-##############################################################################
+############################################################################
 ##
-#M  Kernel( C1A ) . . . . . . . . . . . . . . . . . . . for a pre-cat1-algebra
+#M  Kernel( C1A ) . . . . . . . . . . . . . . . . . . for a pre-cat1-algebra
 ##
 InstallOtherMethod( Kernel, "method for a pre-cat1-algebra", true, 
     [ IsPreCat1Algebra ], 0,
     C1A -> Kernel( TailMap( C1A ) ) );
 
-#############################################################################
+############################################################################
 ##
-#M  Boundary( C1A ) . . . . . . . . . . . . . . . . . . .  for a cat1-algebra
+#M  Boundary( C1A ) . . . . . . . . . . . . . . . . . . . for a cat1-algebra
 ##
 InstallOtherMethod( Boundary, "method for a pre-cat1-algebra", true, 
     [ IsPreCat1Algebra ], 0,
     C1A -> RestrictionMappingAlgebra( HeadMap( C1A ), Kernel( C1A ) ) );
 
-#############################################################################
+############################################################################
 ##
-#M  KernelEmbedding( C1A ) . . .  . . . . . . . . . . . . .  for a cat1-algebra
+#M  KernelEmbedding( C1A ) . . .  . . . . . . . . . . . . for a cat1-algebra
 ##
 InstallMethod( KernelEmbedding, "method for a pre-cat1-algebra", true, 
     [ IsPreCat1Algebra ], 0,
     C1A -> InclusionMappingAlgebra( Source( C1A ), Kernel( C1A ) ) );
 
-##############################################################################
+############################################################################
 ##
 #M  AllCat1Algebras
 ##
@@ -1578,7 +1559,7 @@ function( F, G )
     return Cat1_ler;
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  IsIsomorphicCat1Algebra
 ##
@@ -1637,7 +1618,7 @@ function( C1A1, C1A2 )
     return sonuc;
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  IsomorphicCat1AlgebraFamily
 ##
@@ -1660,7 +1641,7 @@ function( C1A1, C1A1_ler )
     return sonuc;
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  AllCat1AlgebrasUpToIsomorphism
 ##
@@ -1688,7 +1669,7 @@ end );
 
 ##########################  conversion functions  ##########################  
 
-#############################################################################
+############################################################################
 ##
 #M  PreXModAlgebraOfPreCat1Algebra
 ##
@@ -1721,7 +1702,7 @@ function( C1A )
     return PM; 
 end );
 
-##############################################################################
+############################################################################
 ##
 #M  XModAlgebraOfCat1Algebra
 ##
@@ -1740,17 +1721,17 @@ function( C1 )
     return X1;
 end );
 
-##############################################################################
+############################################################################
 ##
-#M  PreCat1AlgebraOfPreXModAlgebra . . . pre-xmod-algebra -> pre-cat1-algebra
+#M  PreCat1AlgebraOfPreXModAlgebra . .  pre-xmod-algebra -> pre-cat1-algebra
 ##
 InstallMethod( PreCat1AlgebraOfPreXModAlgebra,
     "convert a pre-xmod-algebra to a pre-cat1-algebra record", true, 
     [ IsPreXModAlgebra ], 0,
 function( XM )
 
-    local  S, R, act, bdy, P, info, vecP, dimP, dimR, vecR, zR, dimS, vecS, zS, 
-           j, imgs, t, h, e, C;
+    local  S, R, act, bdy, P, info, vecP, dimP, dimR, vecR, zR, dimS, vecS,
+           zS, j, imgs, t, h, e, C;
 
     S := Source( XM );
     R := Range( XM );
@@ -1780,12 +1761,12 @@ function( XM )
     return C; 
 end ); 
 
-##############################################################################
+############################################################################
 ##
 #M  Cat1AlgebraOfXModAlgebra
 ##
-InstallMethod( Cat1AlgebraOfXModAlgebra, "generic method for crossed modules",
-    true, [ IsXModAlgebra ], 0,
+InstallMethod( Cat1AlgebraOfXModAlgebra, 
+    "generic method for crossed modules", true, [ IsXModAlgebra ], 0,
 function( X1 )
 
     local C1; 
diff --git a/lib/algebra.gi b/lib/algebra.gi
index 1223700..f21bdb3 100644
--- a/lib/algebra.gi
+++ b/lib/algebra.gi
@@ -705,6 +705,11 @@ InstallMethod( SemidirectProductOfAlgebras,
                        # result will have the same property.
           P;           # the answer is the semidirect product algebra 
 
+    ## we are assuming commutative algebras so T will be symmetric
+    ## and we only need to calculate the upper triangle
+    if not IsCommutative( A1 ) and IsCommutative( A2 ) then
+        Error( "commutative algebras required" ); 
+    fi;
     F := LeftActingDomain( A1 ); 
     z := Zero( F ); 
     if ( F <> LeftActingDomain( A2 ) ) then
@@ -733,9 +738,8 @@ InstallMethod( SemidirectProductOfAlgebras,
     # Initialize the s.c. table.
     T := EmptySCTable( n, Zero(F), "symmetric" );
     for i in [1..n1] do 
-        r := vec1[i]; 
-        imr := ImageElm( act, r ); 
-        for j in [1..n1] do 
+        r := vec1[i];
+        for j in [i..n1] do 
             u := vec1[j]; 
             ru := Coefficients( bas1, r*u ); 
             L := [ ]; 
@@ -743,9 +747,13 @@ InstallMethod( SemidirectProductOfAlgebras,
                 if ( ru[k] <> z ) then 
                     Append( L, [ ru[k], k ] ); 
                 fi; 
-            od; 
+            od;
             SetEntrySCTable( T, i, j, L ); 
-        od; 
+        od;
+    od;
+    for i in [1..n1] do
+        r := vec1[i]; 
+        imr := ImageElm( act, r ); 
         for j in [1..n2] do 
             v := vec2[j]; 
             rv := Coefficients( bas2, ImageElm( imr, v ) ); 
@@ -760,19 +768,7 @@ InstallMethod( SemidirectProductOfAlgebras,
     od; 
     for i in [1..n2] do 
         s := vec2[i]; 
-        for j in [1..n1] do 
-            u := vec1[j]; 
-            imu := ImageElm( act, u ); 
-            su := Coefficients( bas2, ImageElm( imu, s ) ); 
-            L := [ ]; 
-            for k in [1..n2] do 
-                if ( su[k] <> z ) then 
-                    Append( L, [ su[k], k+n1 ] ); 
-                fi; 
-            od; 
-            SetEntrySCTable( T, i+n1, j, L ); 
-        od; 
-        for j in [1..n2] do 
+        for j in [i..n2] do 
             v := vec2[j]; 
             sv := Coefficients( bas2, s*v ); 
             L := [ ]; 
@@ -783,7 +779,7 @@ InstallMethod( SemidirectProductOfAlgebras,
             od; 
             SetEntrySCTable( T, i+n1, j+n1, L ); 
         od; 
-    od; 
+    od;
     P := AlgebraByStructureConstants( F, T ); 
     SetSemidirectProductOfAlgebrasInfo( P, rec( algebras := [ A1, A2 ], 
                                                 action := act, 
@@ -835,38 +831,30 @@ end );
 InstallMethod( Projection, "semidirect product of algebras and integer",
     [ IsAlgebra and HasSemidirectProductOfAlgebrasInfo, IsPosInt ], 
 function( P, i )
-    local info, vecP, dimP, A1, dim1, z1, A2, dim2, z2, vec1, vec2, 
-          imgs, j, hom;
+    local info, vecP, dimP, A1, dim1, z1, vec1, imgs, j, hom;
+    if ( i <> 1 ) then 
+        Error( "only the first projection is available" ); 
+    fi; 
     # check
     info := SemidirectProductOfAlgebrasInfo( P );
-    if IsBound( info.projections[i] ) then 
-        return info.projections[i];
+    if IsBound( info.projections[1] ) then 
+        return info.projections[1];
     fi;
     vecP := BasisVectors( Basis( P ) ); 
     dimP := Length( vecP ); 
     A1 := info.algebras[1]; 
     dim1 := Dimension( A1 ); 
     z1 := Zero( A1 ); 
-    A2 := info.algebras[2]; 
-    dim2 := Dimension( A2 ); 
-    z2 := Zero( A2 ); 
-    vec1 := BasisVectors( Basis( A1 ) ); 
-    vec2 := BasisVectors( Basis( A2 ) ); 
-    imgs := ListWithIdenticalEntries( dimP, 0 ); 
-    if ( i = 1 ) then 
-        for j in [1..dim1] do 
-            imgs[j] := vec1[j]; 
-        od; 
-        for j in [dim1+1..dimP] do 
-            imgs[j] := z1; 
-        od; 
-        hom := AlgebraHomomorphismByImages( P, A1, vecP, imgs ); 
-    elif ( i = 2 ) then 
-        return fail; 
-    else 
-        Error( "only the first projection is available" ); 
-    fi; 
+    vec1 := BasisVectors( Basis( A1 ) );  
+    imgs := ListWithIdenticalEntries( dimP, 0 );
+    for j in [1..dim1] do 
+        imgs[j] := vec1[j]; 
+    od; 
+    for j in [dim1+1..dimP] do 
+        imgs[j] := z1; 
+    od;
+    hom := AlgebraHomomorphismByImages( P, A1, vecP, imgs );  
     ## SetIsSurjective( hom, true ); 
-    info.projections[i] := hom;
+    info.projections[1] := hom;
     return hom;
 end );
diff --git a/lib/module.gd b/lib/module.gd
index 09b520a..406a0e6 100644
--- a/lib/module.gd
+++ b/lib/module.gd
@@ -26,23 +26,23 @@
 ##
 ## <Example>
 ## <![CDATA[
-## gap> A := Rationals^[3,3];;
-## gap> SetName( A, "Q[3,3]" );;
-## gap> V := Rationals^3;;
-## gap> M := LeftAlgebraModule( A, \*, V );
-## <left-module over Q[3,3]>
-## gap> SetName( M, "M" );
-## gap> famM := ElementsFamily( FamilyObj( M ) );;
-## gap> v := [3,4,5];;
-## gap> v2 := ObjByExtRep( famM, v );                                                                                                                                                                   
 ## gap> m := [ [0,1,0], [0,0,1], [1,0,0] ];;
+## gap> A3 := Rationals^[3,3];;
+## gap> SetName( A3, "A3" );;
+## gap> V3 := Rationals^3;;
+## gap> M3 := LeftAlgebraModule( A3, \*, V3 );;
+## gap> SetName( M3, "M3" );
+## gap> famM3 := ElementsFamily( FamilyObj( M3 ) );;
+## gap> v := [3,4,5];;
+## gap> v2 := ObjByExtRep( famM3, v );
+## [ 3, 4, 5 ]
 ## gap> m*v2;
 ## [ 4, 5, 3 ]
-## gap> genM := GeneratorsOfLeftModule( M );;
-## gap> u2 := 6*genM[1] + 7*genM[2] + 8*genM[3];
-## [ 6, 7, 8 ]
-## gap> u := ExtRepOfObj( u2 );
-## [ 6, 7, 8 ]
+gap> genM3 := GeneratorsOfLeftModule( M3 );;
+gap> u2 := 6*genM3[1] + 7*genM3[2] + 8*genM3[3];
+[ 6, 7, 8 ]
+gap> u := ExtRepOfObj( u2 );
+[ 6, 7, 8 ]
 ## ]]>
 ## </Example>
 ## </Subsection>
@@ -77,15 +77,15 @@
 ## </ManSection>
 ## <Example>
 ## <![CDATA[
-## gap> D := LeftActingDomain( M );;
-## gap> T := EmptySCTable( Dimension(M), Zero(D), "symmetric" );;
-## gap> B := AlgebraByStructureConstants( D, T );
+## gap> D3 := LeftActingDomain( M3 );;
+## gap> T3 := EmptySCTable( Dimension(M3), Zero(D3), "symmetric" );;
+## gap> B3a := AlgebraByStructureConstants( D3, T3 );
 ## <algebra of dimension 3 over Rationals>
-## gap> GeneratorsOfAlgebra( B );
+## gap> GeneratorsOfAlgebra( B3a );
 ## [ v.1, v.2, v.3 ]
-## gap> B := ModuleAsAlgebra( M );               
-## A(M)
-## gap> GeneratorsOfAlgebra( B );
+## gap> B3 := ModuleAsAlgebra( M3 );               
+## A(M3)
+## gap> GeneratorsOfAlgebra( B3 );
 ## [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ]
 ## ]]>
 ## </Example>
@@ -108,9 +108,9 @@ DeclareAttribute( "ModuleAsAlgebra", IsLeftModule );
 ## </ManSection>
 ## <Example>
 ## <![CDATA[
-## gap> IsModuleAsAlgebra( B );
+## gap> IsModuleAsAlgebra( B3 );
 ## true
-## gap> IsModuleAsAlgebra(A);   
+## gap> IsModuleAsAlgebra( A3 );   
 ## false
 ## ]]>
 ## </Example>
@@ -138,23 +138,24 @@ DeclareProperty( "IsModuleAsAlgebra", IsAlgebra );
 ## </ManSection>
 ## <Example>
 ## <![CDATA[
-## gap> KnownAttributesOfObject(B);    
+## gap> KnownAttributesOfObject( B3 );    
 ## [ "Name", "ZeroImmutable", "LeftActingDomain", "Dimension", 
 ##   "GeneratorsOfLeftOperatorAdditiveGroup", "GeneratorsOfLeftOperatorRing", 
 ##   "ModuleToAlgebraIsomorphism", "AlgebraToModuleIsomorphism" ]
-## gap> M2B := ModuleToAlgebraIsomorphism( B );
-## [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] -> [ [[ 1, 0, 0 ]], [[ 0, 1, ## 0 ]], 
+## gap> M2B3 := ModuleToAlgebraIsomorphism( B3 );
+## [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] -> [ [[ 1, 0, 0 ]], [[ 0, \
+## 1, 0 ]], 
 ##   [[ 0, 0, 1 ]] ]
-## gap> Source( M2B ) = M;
+## gap> Source( M2B3 ) = M3;
 ## false
-## gap> Source( M2B ) = V;
+## gap> Source( M2B3 ) = V3;
 ## true
-## gap> B2M := AlgebraToModuleIsomorphism( B );
-## [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] -> 
+## gap> B2M3 := AlgebraToModuleIsomorphism( B3 );
+## [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
 ## [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
-## gap> Range( B2M ) = M;
+## gap> Range( B2M3 ) = M3;
 ## false
-## gap> Range( B2M ) = V;
+## gap> Range( B2M3 ) = V3;
 ## true
 ## ]]>
 ## </Example>
@@ -179,7 +180,7 @@ DeclareAttribute( "AlgebraToModuleIsomorphism", IsAlgebra );
 ## </ManSection>
 ## <Example>
 ## <![CDATA[
-## gap> act := AlgebraActionByModule( A, M );
+## gap> act3 := AlgebraActionByModule( A3, M3 );
 ## [ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
 ##   [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
 ##   [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] ] -> 
@@ -189,17 +190,62 @@ DeclareAttribute( "AlgebraToModuleIsomorphism", IsAlgebra );
 ##     [ [[ 1, 0, 0 ]], 0*[[ 1, 0, 0 ]], 0*[[ 1, 0, 0 ]] ], 
 ##   [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] -> 
 ##     [ [[ 0, 1, 0 ]], [[ 0, 0, 1 ]], [[ 1, 0, 0 ]] ] ]
-## gap> genA := GeneratorsOfAlgebra(A);;
-## gap> m := 5*genA[1] -4*genA[2]+3*genA[3];
-## [ [ 1, 0, 3 ], [ 3, 5, 0 ], [ 0, 3, 5 ] ]
-## gap> Image( act, m );
-## Basis( A(M), [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ) -> 
-## [ [[ 1, 0, 0 ]]+(3)*[[ 0, 1, 0 ]], (5)*[[ 0, 1, 0 ]]+(3)*[[ 0, 0, 1 ]], 
-##   (3)*[[ 1, 0, 0 ]]+(5)*[[ 0, 0, 1 ]] ]
-## gap> Image( act ); 
+## gap> genA3 := GeneratorsOfAlgebra( A3 );;
+## gap> a := 2*m + 3*m^2;
+## [ [ 0, 2, 3 ], [ 3, 0, 2 ], [ 2, 3, 0 ] ]
+## gap> Image( act3, a );
+## Basis( A(M3), [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ) -> 
+## [ (3)*[[ 0, 1, 0 ]]+(2)*[[ 0, 0, 1 ]], (2)*[[ 1, 0, 0 ]]+(3)*[[ 0, 0, 1 ]], 
+##   (3)*[[ 1, 0, 0 ]]+(2)*[[ 0, 1, 0 ]] ]
+## gap> Image( act3 );
 ## <algebra over Rationals, with 3 generators>
 ## ]]>
 ## </Example>
 ## <#/GAPDoc>
 ##
 DeclareOperation( "AlgebraActionByModule", [ IsAlgebra, IsLeftModule ] );
+
+
+############################################################################
+##
+## XModAlgebraByModule( <alg> <leftmod> )
+##
+## <#GAPDoc Label="XModAlgebraByModule"> 
+## <ManSection>
+## <Oper Name="XModAlgebraByModule" Arg="alg leftmod" />
+##
+## <Description>
+## Let <M>M</M> be an <M>A</M>-module.  
+## Then <M>\mathcal{X} = (0 : A(M) \rightarrow A)</M> is a crossed module,
+## where <M>A(M)</M> is <M>M</M> considered as an algebra with zero products
+## (see section <Ref Sect="ModuleAsAlgebra" />).
+## The example uses the action <C>act3</C> constructed in section
+## <Ref Sect="AlgebraActionByModule" />.
+## <P/>
+## Conversely, given a crossed module 
+## <M>\mathcal{X} = (\partial :M\rightarrow R)</M>,
+## one can get that <M>\ker\partial</M> is a <M>(R/\partial M)</M>-module.
+## <P/>
+## </Description>
+## </ManSection>
+## <Example>
+## <![CDATA[
+## gap> X0 := XModAlgebraByModule( A, M );
+## [ A(M) -> Q[3,3] ]
+## gap> Display( X3 );
+## Crossed module [A(M3)->A3] :- 
+## : Source algebra A(M3) has generators:
+##   [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ]
+## : Range algebra A3 has generators:
+##   [ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
+##   [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
+##   [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] ]
+## : Boundary homomorphism maps source generators to:
+##   [ [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
+##   [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
+##   [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ] ]
+## ]]>
+## </Example>
+## <#/GAPDoc>
+##
+DeclareOperation( "XModAlgebraByModule", [ IsAlgebra, IsLeftModule ] );
diff --git a/lib/module.gi b/lib/module.gi
index 795295d..99afe63 100644
--- a/lib/module.gi
+++ b/lib/module.gi
@@ -92,6 +92,30 @@ function( A, M )
         SetName( C, Concatenation( "Act(", Name(B), ")" ) );
     fi;
     act := AlgebraGeneralMappingByImages( A, C, genA, imact );
+    SetIsAlgebraAction( act, true );
+    SetAlgebraActionType( act, "module" );
     return act;
 end );
 
+#############################################################################
+##
+#M  XModAlgebraByModule
+##
+InstallMethod( XModAlgebraByModule, "crossed module from module", true,
+    [ IsAlgebra, IsLeftModule ], 0,
+function( A, M )
+    local  genM, zA, B, genB, dimB, imbdy, bdy, PM, act;
+    genM := GeneratorsOfLeftModule( M );
+    zA := Zero( A );
+    B := ModuleAsAlgebra( M ); 
+    genB := GeneratorsOfAlgebra( B );
+    dimB := Length( genB );
+    imbdy := ListWithIdenticalEntries( dimB, zA );
+    bdy := AlgebraHomomorphismByImages( B, A, genB, imbdy );
+    act := AlgebraActionByModule( A, M );
+    PM := PreXModAlgebraByBoundaryAndAction( bdy, act );
+    if not IsXModAlgebra( PM ) then
+        Error( "this boundary and action only defines a pre-crossed module" );
+    fi;
+    return PM;
+end );
diff --git a/tst/module.tst b/tst/module.tst
deleted file mode 100644
index 9e2a7a5..0000000
--- a/tst/module.tst
+++ /dev/null
@@ -1,96 +0,0 @@
-############################################################################
-##
-#W  module.tst             XModAlg test files                  Chris Wensley 
-## 
-##
-#@local level,A,V,M,famM,v,v2,m,genM,u2,u,D,T,B,M2B,B2M,act,genA
-gap> START_TEST( "XModAlg package: module.tst" );
-gap> level := InfoLevel( InfoXModAlg );; 
-gap> SetInfoLevel( InfoXModAlg, 0 );
-
-## Chapter 2, Section 2.2.3
-gap> A := Rationals^[3,3];;
-gap> SetName( A, "Q[3,3]" );;
-gap> V := Rationals^3;;
-gap> M := LeftAlgebraModule( A, \*, V );
-<left-module over Q[3,3]>
-gap> SetName( M, "M" );
-gap> famM := ElementsFamily( FamilyObj( M ) );;
-gap> v := [3,4,5];;
-gap> v2 := ObjByExtRep( famM, v );
-[ 3, 4, 5 ]
-gap> m := [ [0,1,0], [0,0,1], [1,0,0] ];;
-gap> m*v2;
-[ 4, 5, 3 ]
-gap> genM := GeneratorsOfLeftModule( M );;
-gap> u2 := 6*genM[1] + 7*genM[2] + 8*genM[3];
-[ 6, 7, 8 ]
-gap> u := ExtRepOfObj( u2 );
-[ 6, 7, 8 ]
-
-## Chapter 2, Section 2.2.4
-gap> D := LeftActingDomain( M );;
-gap> T := EmptySCTable( Dimension(M), Zero(D), "symmetric" );;
-gap> B := AlgebraByStructureConstants( D, T );
-<algebra of dimension 3 over Rationals>
-gap> GeneratorsOfAlgebra( B );
-[ v.1, v.2, v.3 ]
-gap> B := ModuleAsAlgebra( M );               
-A(M)
-gap> GeneratorsOfAlgebra( B );
-[ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ]
-
-## Chapter 2, Section 2.2.5
-gap> IsModuleAsAlgebra( B );
-true
-gap> IsModuleAsAlgebra(A);
-false
-
-## Chapter 2, Section 2.2.6
-gap> KnownAttributesOfObject(B);
-[ "Name", "ZeroImmutable", "LeftActingDomain", "Dimension",
-  "GeneratorsOfLeftOperatorAdditiveGroup", "GeneratorsOfLeftOperatorRing",
-  "ModuleToAlgebraIsomorphism", "AlgebraToModuleIsomorphism" ]
-gap> M2B := ModuleToAlgebraIsomorphism( B );
-[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] -> [ [[ 1, 0, 0 ]], [[ 0, \
-1, 0 ]], 
-  [[ 0, 0, 1 ]] ]
-gap> Source( M2B ) = M;
-false
-gap> Source( M2B ) = V;
-true
-gap> B2M := AlgebraToModuleIsomorphism( B );
-[ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
-[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
-gap> Range( B2M ) = M;
-false
-gap> Range( B2M ) = V;
-true
-
-## Chapter 2, Section 2.2.7
-gap> act := AlgebraActionByModule( A, M );
-[ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
-  [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ],
-  [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] ] ->
-[ [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
-    [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ],
-  [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
-    [ [[ 1, 0, 0 ]], 0*[[ 1, 0, 0 ]], 0*[[ 1, 0, 0 ]] ],
-  [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
-    [ [[ 0, 1, 0 ]], [[ 0, 0, 1 ]], [[ 1, 0, 0 ]] ] ]
-gap> genA := GeneratorsOfAlgebra(A);;
-gap> m := 5*genA[1] -4*genA[2]+3*genA[3];
-[ [ 1, 0, 3 ], [ 3, 5, 0 ], [ 0, 3, 5 ] ]
-gap> Image( act, m );
-Basis( A(M), [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ) ->
-[ [[ 1, 0, 0 ]]+(3)*[[ 0, 1, 0 ]], (5)*[[ 0, 1, 0 ]]+(3)*[[ 0, 0, 1 ]],
-  (3)*[[ 1, 0, 0 ]]+(5)*[[ 0, 0, 1 ]] ]
-gap> Image( act );
-<algebra over Rationals, with 3 generators>
-
-gap> SetInfoLevel( InfoXModAlg, level );; 
-gap> STOP_TEST( "module.tst", 10000 );
-
-############################################################################
-##
-#E  module.tst  . . . . . . . . . . . . . . . . . . . . . . . . . ends here
diff --git a/tst/module3.tst b/tst/module3.tst
new file mode 100644
index 0000000..cdfecea
--- /dev/null
+++ b/tst/module3.tst
@@ -0,0 +1,112 @@
+############################################################################
+##
+#W  module3.tst             XModAlg test files                 Chris Wensley 
+## 
+##
+#@local level,m,A3,V3,M3,famM3,v,v2,genM3,u2,u,D3,T3,B3a,B3,M2B3,B2M3,act3,genA3,a
+gap> START_TEST( "XModAlg package: module.tst" );
+gap> level := InfoLevel( InfoXModAlg );; 
+gap> SetInfoLevel( InfoXModAlg, 0 );
+
+## Chapter 2, Section 2.2.3
+gap> m := [ [0,1,0], [0,0,1], [1,0,0] ];;
+gap> A3 := Rationals^[3,3];;
+gap> SetName( A3, "A3" );;
+gap> V3 := Rationals^3;;
+gap> M3 := LeftAlgebraModule( A3, \*, V3 );;
+gap> SetName( M3, "M3" );
+gap> famM3 := ElementsFamily( FamilyObj( M3 ) );;
+gap> v := [3,4,5];;
+gap> v2 := ObjByExtRep( famM3, v );
+[ 3, 4, 5 ]
+gap> m*v2;
+[ 4, 5, 3 ]
+gap> genM3 := GeneratorsOfLeftModule( M3 );;
+gap> u2 := 6*genM3[1] + 7*genM3[2] + 8*genM3[3];
+[ 6, 7, 8 ]
+gap> u := ExtRepOfObj( u2 );
+[ 6, 7, 8 ]
+
+## Chapter 2, Section 2.2.4
+gap> D3 := LeftActingDomain( M3 );;
+gap> T3 := EmptySCTable( Dimension(M3), Zero(D3), "symmetric" );;
+gap> B3a := AlgebraByStructureConstants( D3, T3 );
+<algebra of dimension 3 over Rationals>
+gap> GeneratorsOfAlgebra( B3a );
+[ v.1, v.2, v.3 ]
+gap> B3 := ModuleAsAlgebra( M3 );               
+A(M3)
+gap> GeneratorsOfAlgebra( B3 );
+[ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ]
+
+## Chapter 2, Section 2.2.5
+gap> IsModuleAsAlgebra( B3 );
+true
+gap> IsModuleAsAlgebra( A3 );
+false
+
+## Chapter 2, Section 2.2.6
+gap> KnownAttributesOfObject( B3 );
+[ "Name", "ZeroImmutable", "LeftActingDomain", "Dimension",
+  "GeneratorsOfLeftOperatorAdditiveGroup", "GeneratorsOfLeftOperatorRing",
+  "ModuleToAlgebraIsomorphism", "AlgebraToModuleIsomorphism" ]
+gap> M2B3 := ModuleToAlgebraIsomorphism( B3 );
+[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] -> [ [[ 1, 0, 0 ]], [[ 0, \
+1, 0 ]], 
+  [[ 0, 0, 1 ]] ]
+gap> Source( M2B3 ) = M3;
+false
+gap> Source( M2B3 ) = V3;
+true
+gap> B2M3 := AlgebraToModuleIsomorphism( B3 );
+[ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
+[ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
+gap> Range( B2M3 ) = M3;
+false
+gap> Range( B2M3 ) = V3;
+true
+
+## Chapter 2, Section 2.2.7
+gap> act3 := AlgebraActionByModule( A3, M3 );
+[ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
+  [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ],
+  [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] ] ->
+[ [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
+    [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ],
+  [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
+    [ [[ 1, 0, 0 ]], 0*[[ 1, 0, 0 ]], 0*[[ 1, 0, 0 ]] ],
+  [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ->
+    [ [[ 0, 1, 0 ]], [[ 0, 0, 1 ]], [[ 1, 0, 0 ]] ] ]
+gap> genA3 := GeneratorsOfAlgebra( A3 );;
+gap> a := 2*m + 3*m^2;
+[ [ 0, 2, 3 ], [ 3, 0, 2 ], [ 2, 3, 0 ] ]
+gap> Image( act3, a );
+Basis( A(M3), [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ] ) -> 
+[ (3)*[[ 0, 1, 0 ]]+(2)*[[ 0, 0, 1 ]], (2)*[[ 1, 0, 0 ]]+(3)*[[ 0, 0, 1 ]], 
+  (3)*[[ 1, 0, 0 ]]+(2)*[[ 0, 1, 0 ]] ]
+gap> Image( act3 );
+<algebra over Rationals, with 3 generators>
+
+## Chapter 4, Section 4.1.7
+gap> X3 := XModAlgebraByModule( A3, M3 );
+[A(M3)->A3]
+gap> Display( X3 );
+
+Crossed module [A(M3)->A3] :- 
+: Source algebra A(M3) has generators:
+  [ [[ 1, 0, 0 ]], [[ 0, 1, 0 ]], [[ 0, 0, 1 ]] ]
+: Range algebra A3 has generators:
+  [ [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], 
+  [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
+  [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ] ]
+: Boundary homomorphism maps source generators to:
+  [ [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
+  [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ], 
+  [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ] ]
+
+gap> SetInfoLevel( InfoXModAlg, level );; 
+gap> STOP_TEST( "module.tst", 10000 );
+
+############################################################################
+##
+#E  module3.tst . . . . . . . . . . . . . . . . . . . . . . . . . ends here