# GAP Implementation
# $Id: homomorphisms.gi,v 1.40 2012/09/28 12:57:10 sunnyquiver Exp $

#############################################################################
##
#M  ImageElm( <map>, <elm> )  . . . for PathAlgebraMatModuleMap and element
##
InstallMethod( ImageElm, 
    "for a map between representations and an element in a representation.",
    [ IsPathAlgebraMatModuleHomomorphism, IsAlgebraModuleElement ], 0, 
    function( map, elem )

    local elt, n, fam, image, temp, zero, new_image;

    if elem in Source(map) then
        if Dimension(Range(map)) = 0 then
            return Zero(Range(map));
        fi;
   elt := ExtRepOfObj(elem);
        n := Zero(Range(map));
        image := List([1..Length(elt![1])], x -> elt![1][x]*map!.maps[x]);

        image := PathModuleElem(FamilyObj(Zero(Range(map))![1]),image);        
        return Objectify( TypeObj( n ), [ image ] );
    else
        Error("the element entered is not an element in the source of the map,");
    fi; 
end);

#############################################################################
##
#M  ImagesSet( <map>, <elms> ) . . for a PathAlgebraMatModuleMap and finite collection
##
InstallMethod( ImagesSet, 
    "for a map between representations and a set of elements in a representation.",
    [ IsPathAlgebraMatModuleHomomorphism, IsCollection ], 0, 
    function( map, elms )

    local elt, B, images;

    images := [];
    if IsList(elms) then
        if IsFinite(elms) then
            B := elms;
        fi;
    else
        if IsPathAlgebraMatModule(elms) then 
            B := BasisVectors(CanonicalBasis(elms));
        else
            Error("input of wrong type,");
        fi;
    fi;
    for elt in B do
       if ImageElm(map,elt) <> Zero(Range(map)) then 
          Add(images,ImageElm(map,elt));
       fi;
    od;
    return images;
end
);
#############################################################################
##
#M  PreImagesRepresentative( <map>, <elms> ) . . for a 
##                              PathAlgebraMatModuleMap and finite collection
##
InstallMethod( PreImagesRepresentative, 
    "for a map between representations and an element in a representation.",
    [ IsPathAlgebraMatModuleHomomorphism, IsAlgebraModuleElement ], 0, 
    function( map, elem )

    local elt, m, fam, preimage;

    if elem in Range(map) then
        elt := ExtRepOfObj(elem)![1];
        m := Basis(Source(map))[1];
        preimage := List([1..Length(elt)], x -> SolutionMat(map!.maps[x],elt[x]));
        if ForAll(preimage,x -> x <> fail) then 
           preimage := PathModuleElem(FamilyObj(Zero(Source(map))![1]),preimage);        
           return Objectify( TypeObj( m ), [ preimage ] );
        else
    return fail;
        fi;
    else
        Error("the element entered is not an element in the range of the map,");
    fi; 
end);

#######################################################################
##
#O  RightModuleHomOverAlgebra( <M>, <N>, <linmaps> )
##
##  This function constructs a homomorphism  f  from the module  <M>  to
##  the module  <N>  from the linear maps given in  <linmaps>. The 
##  function checks if  <M>  and  <N>  are modules over the same algebra 
##  and checks if the linear maps  <linmaps>  defines a homomorphism from  
##  <M>  to  <N>. The source and the range of  f  can be recovered from 
##  f  via the function  Source(f)  and  Range(f). The linear maps can 
##  be recovered via  f!.maps  or  
##  MatricesOfPathAlgebraMatModuleHomomorphism(f).
##
InstallMethod( RightModuleHomOverAlgebra,
    "for two representations of a quiver",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule, IsList ], 0,
    function( M, N, linmaps)

    local A, K, mat_M, mat_N, map, Fam, dim_M, dim_N, Q, arrows, 
        vertices, a, i, origin, target, j;

    A := RightActingAlgebra(M); 
    if A <> RightActingAlgebra(N) then
        Error("the two modules are not over the same algebra, ");
    fi;
    dim_M := DimensionVector(M);
    dim_N := DimensionVector(N);
#
# Checking the number of matrices entered. 
#
    if Length( linmaps ) <> Length(dim_M) then 
        Error("the number of matrices entered is wrong,");
    fi;     
#
# Check the matrices of linmaps
#
    K := LeftActingDomain(A);
    for i in [1..Length(dim_M)] do
        if ( dim_M[i] = 0 ) then 
            if dim_N[i] = 0 then 
         if linmaps[i] <> NullMat(1,1,K) then 
                     Error("the dimension of matrix number ",i," is wrong (A),");
                fi; 
            else
                if linmaps[i] <> NullMat(1,dim_N[i],K) then
                    Error("the dimension of matrix number ",i," is wrong (B),");
                fi;
            fi;
        else
            if dim_N[i] = 0 then
                if linmaps[i] <> NullMat(dim_M[i],1,K) then 
                    Error("the dimension of matrix number ",i," is wrong (C),");
                fi;
            else          
                if DimensionsMat(linmaps[i])[1] <> dim_M[i] or DimensionsMat(linmaps[i])[2] <> dim_N[i] then
                    Error("the dimension of matrix number ",i," is wrong (D),"); 
                fi;
            fi;
        fi;   
    od;
# 
# Check commutativity relations with the matrices in M and N.
#
    mat_M := MatricesOfPathAlgebraModule(M);
    mat_N := MatricesOfPathAlgebraModule(N);
    Q := QuiverOfPathAlgebra(A);
    arrows   := ArrowsOfQuiver(Q);
    vertices := VerticesOfQuiver(Q);
    for a in arrows do
        i := Position(arrows,a); 
        origin := Position(vertices,SourceOfPath(a));
        target := Position(vertices,TargetOfPath(a)); 
        if mat_M[i]*linmaps[target] <> linmaps[origin]*mat_N[i] then 
            Error("entered map is not a module map between the representations entered, error for vertex number ",i," and arrow ",a,",");
        fi;
    od;
#
#
    map := Objectify( NewType( CollectionsFamily( GeneralMappingsFamily(
                   ElementsFamily( FamilyObj( M ) ),
                   ElementsFamily( FamilyObj( N ) ) ) ), 
                   IsPathAlgebraMatModuleHomomorphism and IsPathAlgebraMatModuleHomomorphismRep ), rec( maps := linmaps ));
    SetPathAlgebraOfMatModuleMap(map, A);
    SetSource(map, M);
    SetRange(map, N);  
    SetIsWholeFamily(map, true);
    
    return map;
end 
);

#######################################################################
##
#O  MatricesOfPathAlgebraMatModuleHomomorphism( <f> )
##
##  This function returns the matrices defining the homomorphism
##  <f>. 
##
InstallMethod( MatricesOfPathAlgebraMatModuleHomomorphism, 
    "for a PathAlgebraMatModuleHomomorphism",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    return f!.maps;  
end
);

#######################################################################
##
#M  ViewObj( <f> )
##
##  This function defines how View prints a 
##  PathAlgebraMatModuleHomomorphism  <f>.
##
InstallMethod( ViewObj, 
    "for a PathAlgebraMatModuleHomomorphism",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ], NICE_FLAGS+1,
    function ( f );

    Print("<");
    View(Source(f));
    Print(" ---> ");
    View(Range(f));
    Print(">");
end
); 

#######################################################################
##
#M  PrintObj( <f> )
##
##  This function defines how Print prints a 
##  PathAlgebraMatModuleHomomorphism  <f>.
##
InstallMethod( PrintObj, 
    "for a PathAlgebraMatModuleHomomorphism",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ], NICE_FLAGS + 1,
    function ( f );

    Print("<",Source(f)," ---> ",Range(f),">");
end
); 

#######################################################################
##
#M  Display( <f> )
##
##  This function defines how Display prints a 
##  PathAlgebraMatModuleHomomorphism  <f>.
##
InstallMethod( Display, 
    "for a PathAlgebraMatModuleHomomorphism",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ], NICE_FLAGS + 1,
    function ( f )
    
    local i;

    Print(f);
    Print("\nwith ");
    for i in [1..Length(DimensionVector(Source(f)))] do
        Print("linear map for vertex number ",i,":\n");
        PrintArray(f!.maps[i]);
    od;
end
); 

#######################################################################
##
#M  Zero( <f> )
##
##  This function returns the zero mapping with the same source and 
##  range as  <f>. 
##
InstallMethod ( Zero, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    
    local M, N, K, dim_M, dim_N, i, mats;

    M := Source(f);
    N := Range(f);
    K := LeftActingDomain(Source(f));
    dim_M := DimensionVector(M);
    dim_N := DimensionVector(N);
    mats := [];
    for i in [1..Length(dim_M)] do
        if dim_M[i] = 0 then
            if dim_N[i] = 0 then 
                Add(mats,NullMat(1,1,K));
            else
                Add(mats,NullMat(1,dim_N[i],K));
            fi;
        else
            if dim_N[i] = 0 then 
                Add(mats,NullMat(dim_M[i],1,K));
            else
                Add(mats,NullMat(dim_M[i],dim_N[i],K));
            fi;
        fi;
    od;
  
    return RightModuleHomOverAlgebra(Source(f),Range(f),mats);
end
);

#######################################################################
##
#M  ZeroMapping( <M>, <N> )
##
##  This function returns the zero mapping from the module  <M>  to the 
##  module  <N>. 
##
InstallMethod ( ZeroMapping, 
    " between two PathAlgebraMatModule's ",
    true,
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
    0,
    function( M, N )
    
    local A, K, dim_M, dim_N, i, mats;

    A := RightActingAlgebra(M);
    if ( A = RightActingAlgebra(N) ) then 
        K := LeftActingDomain(M);
        dim_M := DimensionVector(M);
        dim_N := DimensionVector(N);
        mats  := [];
        for i in [1..Length(dim_M)] do
            if dim_M[i] = 0 then
                if dim_N[i] = 0 then 
                    Add(mats,NullMat(1,1,K));
                else
                    Add(mats,NullMat(1,dim_N[i],K));
                fi;
            else
                if dim_N[i] = 0 then 
                    Add(mats,NullMat(dim_M[i],1,K));
                else
                    Add(mats,NullMat(dim_M[i],dim_N[i],K));
                fi;
            fi;
        od;
  
        return RightModuleHomOverAlgebra(M,N,mats);
    else
        Error("the two modules entered are not modules of one and the same algebra, or they are not modules over the same (quotient of a) path algebra, ");
    fi;
end
);

#######################################################################
##
#M  IdentityMapping( <M> )
##
##  This function returns the identity homomorphism from  <M>  to  <M>.
##
InstallMethod ( IdentityMapping, 
    "for a PathAlgebraMatModule",
    true,
    [ IsPathAlgebraMatModule ],
    0,
    function( M )
    
    local K, dim_M, i, mats;
#
# Representing the identity map from M to M with identity matrices 
# of the right size, including if dim_M[i] = 0, then the identity 
# is represented by a one-by-one identity matrix.
#
    K := LeftActingDomain(M);
    dim_M := DimensionVector(M);
    mats := [];
    for i in [1..Length(dim_M)] do
        if dim_M[i] = 0 then
            Add(mats,NullMat(1,1,K));
        else
            Add(mats,IdentityMat(dim_M[i],K));
        fi;
    od;
    
    return RightModuleHomOverAlgebra(M,M,mats);
end
);

#######################################################################
##
#M  \=( <f>, <g> )
##
##  This function returns true if the homomorphisms  <f>  and  <g>  have
##  the same source, the same range and the matrices defining the 
##  homomorphisms are identitical.
##
InstallMethod ( \=, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f, g )
    
    local a;

    if ( Source(f) = Source(g) ) and ( Range(f) = Range(g) ) 
       and ( f!.maps = g!.maps ) then
        return true;
    else
        return false;
    fi;
end
);

#######################################################################
##
#O  SubRepresentationInclusion( <M>, <gen> )
##
##  This function returns the inclusion from the submodule of  <M>  
##  generated by the elements  <gen>  to the module  <M>. The function
##  checks if all the elements on the list  <gen>  are elements of  the
##  module  <M>. 
##
InstallMethod( SubRepresentationInclusion,
    "for a path algebra module and list of its elements",
    true,
    [IsPathAlgebraMatModule, IsList], 0,
    function( M, gen )

    local A, q, K, num_vert, basis_M, vertices, arrows_as_path, arrows_of_quiver, 
          newgen, g, v, submodspan, temp, new, V_list, m, V, basis_submod, submod_list, 
          dim_vect_sub, i, cnt, j, dim_size, s, t, big_mat, a, mat, dom_a, im_a, pd, 
          pi, arrow, submodule, dim_vect_M, dim_size_M, inclusion, map;

    if not ForAll(gen, g -> g in M) then
        Error("entered elements are not in the module <M>, ");
    fi;

    A := RightActingAlgebra(M);
    q := QuiverOfPathAlgebra(A);
    K := LeftActingDomain(M);
    num_vert := Length(VerticesOfQuiver(q));
    basis_M := Basis(M);
#
# vertices, vertices as elements of algebra
# arrows_as_path, arrows as elements of algebra
# arrows, as arrows in the quiver
#
    if Length(gen) = 0 then 
        return ZeroMapping(ZeroModule(A),M);
    else
        vertices := List(VerticesOfQuiver(q), x -> x*One(A));
        arrows_as_path := List(ArrowsOfQuiver(q), x -> x*One(A));
        arrows_of_quiver := GeneratorsOfQuiver(q){[1+num_vert..num_vert+Length(ArrowsOfQuiver(q))]};
#
# Ensuring uniform generators
#
        newgen := [];
        for g in gen do 
            for v in vertices do 
                if g^v <> Zero(M) then 
                    Add(newgen,g^v);
                fi;
            od;
        od;
#
# Finding the linear span of the submodule generated by gen in M
#  
        submodspan := [];
        temp := [];
        new := newgen;
        while new <> [] do
            for m in new do
                for a in arrows_as_path do
                    if m^a <> Zero(M) then
                        Add(temp,m^a);            
                    fi;
                od;
            od;
            Append(submodspan,new);
            new := temp;
            temp := [];
        od;
        V_list := List(submodspan, x -> Coefficients(basis_M,x));
        V := VectorSpace(K,V_list);
        basis_submod := CanonicalBasis(V);
#
# Converting elements in basis_submod to a list of elements in M 
#
        submod_list := List(basis_submod, x -> LinearCombination(basis_M,x));
#
# Finding the dimension vector of the submodule of M
#
        dim_vect_sub:=[];
        for i in [1.. num_vert] do
            cnt := 0;
            for j in [1..Length(submod_list)] do
                if submod_list[j]^vertices[i] <> Zero(M) then
                    cnt:=cnt+1;   
                fi;
            od;
            Add(dim_vect_sub,cnt);    
        od;
        if Dimension(V) <> Sum(dim_vect_sub) then
            Error("Bug alert: Something is wrong in this code! Report this.\n");
        fi;
#    
# CanonicalBasis(V) gives the basis in "upper triangular form", so that 
# first comes the basis vectors for the vector space in vertex 1, in 
# vertex 2, ...., in vertex n. Next we find the intervals of the basis
# vector [[?..?],[?..?],...,[?..?]]. Is no basis vectors for a vertex, [] is entered.
#
        dim_size := [];
        s := 1;
        t := 0;
        for i in [1..Length(vertices)] do
            t := dim_vect_sub[i] + t;
            if t < s then 
                Add(dim_size,[]);
            else
                Add(dim_size,[s..t]);
            fi;
            s := t + 1;
        od;  
#
# Finding the submodule as a representation of the quiver
#  
        big_mat := [];
        for a in arrows_as_path do
            mat := [];
            for v in vertices do
                if v*a <> Zero(A) then
                    dom_a := v;
                fi;
            od;
            for v in vertices do
                if a*v <> Zero(A) then
                    im_a := v;
                fi;
            od; 
            
            pd := Position(vertices,dom_a);
            pi := Position(vertices,im_a);
            
            arrow := arrows_of_quiver[Position(arrows_as_path,a)];
            if dim_vect_sub[pd] <> 0 and dim_vect_sub[pi] <> 0 then 
                for m in submod_list{dim_size[pd]} do
                    Add(mat,Coefficients(basis_submod,Coefficients(basis_M,m^a)){dim_size[pi]}); 
                od;
                Add(big_mat,[String(arrow),mat]);
            fi;
        od;
        
        if IsPathAlgebra(A) then 
            submodule := RightModuleOverPathAlgebra(A, dim_vect_sub, big_mat);
        else
            submodule := RightModuleOverPathAlgebra(A, dim_vect_sub, big_mat); 
        fi;      

#
# Finding inclusion map of submodule into M
#
        mat := [];
        for i in [1..Length(basis_submod)] do
            Add(mat,basis_submod[i]);
        od;
        
        dim_vect_M := DimensionVector(M);
        dim_size_M := [];
        s := 1;
        t := 0;
        for i in [1..Length(vertices)] do
            t := dim_vect_M[i] + t;
            if t < s then 
                Add(dim_size_M,[]);
            else
                Add(dim_size_M,[s..t]);
            fi;
            s := t + 1;
        od;
        
        inclusion := [];
        for i in [1..Length(vertices)] do
            if dim_vect_sub[i] = 0 then
                if dim_vect_M[i] = 0 then 
                    Add(inclusion,NullMat(1,1,K));
                else
                    Add(inclusion,NullMat(1,dim_vect_M[i],K)); 
                fi;
            else 
                Add(inclusion,mat{dim_size[i]}{dim_size_M[i]});
            fi;
        od;
        return RightModuleHomOverAlgebra(submodule,M,inclusion);
    fi;
end
);

#######################################################################
##
#O  SubRepresentation( <M>, <gen> )
##
##  This function returns a module isomorphic to the submodule of  <M>  
##  generated by the elements  <gen>  to the module  <M>. The function
##  checks if all the elements on the list  <gen>  are elements of  the
##  module  <M>. 
##
InstallMethod( SubRepresentation,
    "for a path algebra module and list of its elements",
    true,
    [ IsPathAlgebraMatModule, IsList], 0,
    function( M, gen );

    return Source(SubRepresentationInclusion(M,gen));
end
);

#######################################################################
##
#O  RadicalOfModuleInclusion( <M> )
##
##  This function returns the inclusion from the radical of  <M>  
##  to the module  <M>. 
##
InstallMethod( RadicalOfModuleInclusion,
    "for a path algebra module",
    true,
    [ IsPathAlgebraMatModule ], 0,
    function( M )

    local A, q, num_vert, arrows_as_path, basis_M, generators, a, b, run_time; 
    
    #
    # Checking if the algebra  <A>  is finite dimensional.  If it is and is 
    # a path algebra, then the radical is the ideal generated by the arrows.  
    # If it is not a path algebra but an admissible quotient of a path algebra,
    # the radical is the ideal generated by the arrows, and this function 
    # applies. 
    #
    A := RightActingAlgebra(M);
    q := QuiverOfPathAlgebra(A);
    if not IsFiniteDimensional(A) then
        TryNextMethod();
    fi; 
    if not IsPathAlgebra(A) and not IsAdmissibleQuotientOfPathAlgebra(A) then
        TryNextMethod();
    fi;

    num_vert := Length(VerticesOfQuiver(q));
#
# Note arrows_as_path will change if A is a quotient of a path algebra !!!!
#
    arrows_as_path := List(ArrowsOfQuiver(q), x -> x*One(A));
    basis_M := Basis(M);
    generators := [];
    for a in arrows_as_path do
        for b in basis_M do 
            if b^a <> Zero(M) then 
                Add(generators,b^a);
            fi;
        od;
    od;
    
    generators := Unique(generators);
    return SubRepresentationInclusion(M,generators);
end
);

#######################################################################
##
#O  RadicalOfModule( <M> )
##
##  This function returns a module isomorphic to the radical of  <M>. 
##
InstallMethod( RadicalOfModule,
    "for a path algebra module",
    true,
    [ IsPathAlgebraMatModule ], 0,
    function( M )

    return Source(RadicalOfModuleInclusion(M));
end
);

#######################################################################
##
#M  IsInjective( <f> )
##
##  This function returns a module isomorphic to the radical of  <M>. 
##
InstallOtherMethod ( IsInjective, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    
    local M, K, V_list, dim_K, dim_M, i, VS_list;

    M := Source(f);
    K := LeftActingDomain(M);
    V_list := [];
    dim_K := 0;
    dim_M := DimensionVector(M);
#
# Computing the kernel of each f_i and making a vector space of Ker f_i with 
# basis given by the vectors supplied by NullspaceMat(f!.maps[i]).
#
    for i in [1..Length(dim_M)] do
        if dim_M[i] <> 0 then 
            dim_K := dim_K + Length(NullspaceMat(f!.maps[i]));
        fi;
    od;
    if dim_K = 0 then
        SetIsInjective(f,true);
        return true;
    else
        SetIsInjective(f,false);
        return false;
    fi;
end
);

#######################################################################
##
#O  KernelInclusion( <f> )
##
##  This function returns the inclusion from a module isomorphic to the 
##  kernel of  <f>  to the module  <M>. 
##
InstallMethod ( KernelInclusion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    
    local M, dim_M, V_list, V_dim, i, dim_K, VS_list, A, K, vertices, 
            arrows, mats, kermats, a, apos, j, matrix, k, Kerf, kermap;

    M := Source(f);
    K := LeftActingDomain(M);
    V_list := [];
    dim_K  := [];
    dim_M := DimensionVector(M);
    VS_list := [];
#
# Computing the kernel of each f_i and making a vector space of Ker f_i with 
# basis given by the vectors supplied by NullspaceMat(f!.maps[i]).
#
    for i in [1..Length(dim_M)] do
        if dim_M[i] <> 0 then
            Add(V_list,NullspaceMat(f!.maps[i]));
            Add(dim_K,Length(V_list[i]));
            if Length(V_list[i]) > 0 then 
                Add(VS_list,VectorSpace(K,V_list[i],"basis"));
            else
                Add(VS_list,TrivialSubmodule(VectorSpace(K,[[One(K)]])));
            fi;
        else
            Add(V_list,[]);
            Add(dim_K,0);
            Add(VS_list,TrivialSubmodule(VectorSpace(K,[[One(K)]])));
        fi;
    od;
    V_list := List(VS_list, V -> Basis(V));
    V_dim := Sum(dim_K);
    A := RightActingAlgebra(M);
    if V_dim = 0 then 
        SetIsInjective(f,true);
        kermap := ZeroMapping(ZeroModule(A),Source(f)); 
    else 
        vertices := VerticesOfQuiver(QuiverOfPathAlgebra(A));
        arrows := ArrowsOfQuiver(QuiverOfPathAlgebra(A));
        mats := MatricesOfPathAlgebraModule(M);
        kermats := [];
#
# The matrices f_alpha of the representation M is used to compute
# the induced action on the basis of Ker f_i.
#
        for a in arrows do
            i := Position(vertices,SourceOfPath(a));
            j := Position(vertices,TargetOfPath(a));
            if dim_K[i] <> 0 and dim_K[j] <> 0 then
                apos := Position(arrows,a);
                matrix := [];
                for k in [1..Length(V_list[i])] do
                    Add(matrix,Coefficients(V_list[j],V_list[i][k]*mats[apos]));
                od;
                Add(kermats,[String(a),matrix]);
            fi;
        od;
#
# Extracting the basis vectors of each Ker f_i, as a subspace of M_i,
# which give the matrices of the inclusion of Ker f  into M.
#
        for i in [1..Length(dim_M)] do
            if Dimension(VS_list[i]) = 0 then
                V_list[i] := []; 
                if dim_M[i] = 0 then 
                    Add(V_list[i],Zero(K));
                else 
                    for j in [1..dim_M[i]] do
                        Add(V_list[i],Zero(K));
                    od;
                fi;
                V_list[i] := [V_list[i]];
            else 
                V_list[i] := BasisVectors(V_list[i]);
            fi;
        od;
        if IsPathAlgebra(A) then 
            Kerf := RightModuleOverPathAlgebra(A, dim_K, kermats);
        else 
            Kerf := RightModuleOverPathAlgebra(A, dim_K, kermats);
        fi;
        kermap := RightModuleHomOverAlgebra(Kerf,M,V_list);
    fi;  
    SetKernelOfWhat(kermap,f);
    SetIsInjective(kermap,true);
    return kermap;
end
);

#######################################################################
##
#M  Kernel( <f> )
##
##  This function returns a module isomorphic to the kernel of  <f>.
##
InstallOtherMethod ( Kernel, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    return Source(KernelInclusion(f));
end
);

#######################################################################
##
#O  ImageProjectionInclusion( <f> )
##
##  This function returns a projection from the source of  <f>  to a 
##  module isomorphic to the image of  <f>  and an inclusion from a 
##  module isomorphic to the image of  <f>  to the module  <M>. 
##
InstallMethod ( ImageProjectionInclusion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    
    local M, N, image, images, A, K, num_vert, vertices, arrows, gen_list, B, i,fam, n, s, v,
          pos, dim_M, dim_N, V, W, projection, dim_image, basis_image, basis_M, basis_N, a, b, image_mat, 
          mat, mats, source_a, target_a, pos_a, bb, image_f, C, map, partmap,
          inclusion, image_inclusion, image_projection, dimvecimage_f;

    M := Source( f );
    N := Range( f );
    A := RightActingAlgebra( M );
    K := LeftActingDomain( M ); 
    num_vert := Length( VerticesOfQuiver( QuiverOfPathAlgebra( A ) ) );
#
    vertices := List( VerticesOfQuiver( QuiverOfPathAlgebra( A ) ), x -> x * One( A ) );
#
# Finding a basis for the vector space in each vertex for the image
#
    image := ImagesSet( f, Source( f ) );
    gen_list := [ ];
    for i in [ 1..Length( vertices ) ] do
        Add( gen_list,[ ] );
    od;
    if Length( image ) > 0 then 
        for n in image do
            for v in vertices do
                if n^v <> Zero( N ) then
                    pos := Position( vertices, v );
                    Add( gen_list[ pos ], ExtRepOfObj( n )![ 1 ][ pos ] );
                fi;
            od;
        od;
        dim_N := DimensionVector( N );
        V := [];    
        W := [];
        basis_image := [];   
        basis_N := [];   
        for i in [ 1..Length( vertices ) ] do
            V[ i ] := K^dim_N[ i ];
            basis_N[ i ] := CanonicalBasis( V[ i ] );
            W[ i ] := Subspace( V[ i ], gen_list[ i ] );
            Add( basis_image, CanonicalBasis( W[ i ] ) );
        od;
#
# Finding the matrices of the representation image
#
        arrows := ArrowsOfQuiver( QuiverOfPathAlgebra( A ) );
        mats := MatricesOfPathAlgebraModule( N );
        image_mat := [ ];
        for a in arrows do 
            mat := [ ];
            pos_a := Position( arrows, a );
            source_a := Position( vertices, SourceOfPath( a ) * One( A ) );
            target_a := Position( vertices, TargetOfPath( a ) * One( A ) );
            if ( Length( basis_image[ source_a ]) <> 0 ) and ( Length( basis_image[ target_a ] ) <> 0 ) then 
         for b in basis_image[ source_a ] do
                    Add( mat, Coefficients( basis_image[ target_a ], b * mats[ pos_a ] ) );
                od;
                Add( image_mat, [ String( a ), mat ] );
            fi;
        od;

 dimvecimage_f := List( W, Dimension );
 image_f := RightModuleOverPathAlgebra( A, dimvecimage_f, image_mat );
#
# Finding inclusion map from the image to Range(f)
#     
        inclusion := [ ];
        for i in [ 1..num_vert ] do 
            mat := [ ];
            if Length( basis_image[ i ] ) = 0 then 
                if dim_N[ i ] = 0 then 
                    Add( inclusion, NullMat( 1, 1, K ) );
                else
                    Add( inclusion, NullMat( 1, dim_N[ i ], K ) );
                fi;
            else
                mat := [ ];
                for b in basis_image[ i ] do 
                    Add( mat, b );
                od;
                Add( inclusion, mat );
            fi;
        od; 
        image_inclusion := RightModuleHomOverAlgebra( image_f, Range( f ), inclusion );
        SetImageOfWhat( image_inclusion, f );
        SetIsInjective( image_inclusion, true );
#
# Finding the projection for Source(f) to the image
#
        dim_M := DimensionVector(M);
        basis_M := [];
        for i in [1..num_vert] do
            Add(basis_M,CanonicalBasis(K^dim_M[i]));
        od;
        projection := [];
        for i in [1..num_vert] do
            mat := [];
            if Length(basis_image[i]) = 0 then
                if dim_M[i] = 0 then  
                    mat := NullMat(1,1,K);
                else
                    mat := NullMat(dim_M[i],1,K);
                fi;
                Add(projection,mat);
            else 
                for b in basis_M[i] do
                    Add(mat,Coefficients(basis_image[i],b*f!.maps[i]));
                od;
                Add(projection,mat);
            fi;
        od;
        image_projection := RightModuleHomOverAlgebra(Source(f),image_f,projection);
        SetImageOfWhat(image_projection,f);
        SetIsSurjective(image_projection,true);
        
        return [image_projection,image_inclusion];
    else
        return [ZeroMapping(M,ZeroModule(A)),ZeroMapping(ZeroModule(A),N)];
    fi;
end
);

#######################################################################
##
#O  ImageProjection( <f> )
##
##  This function returns a projection from the source of  <f>  to a 
##  module isomorphic to the image of  <f>. 
##
InstallMethod ( ImageProjection, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f );

    return ImageProjectionInclusion(f)[1];
end
);

#######################################################################
##
#O  ImageInclusion( <f> )
##
##  This function returns an inclusion from a module isomorphic to the 
##  image of  <f>  to the module  <M>. 
##
InstallMethod ( ImageInclusion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f );

    return ImageProjectionInclusion(f)[2];
end
);

#######################################################################
##
#M  ImagesSource( <f> )
##
##  This function returns a module isomorphic to the image of  <f>. 
##  TODO: Should this delegate to ImagesSet as for the general GAP
##  command?
##
InstallMethod ( ImagesSource, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f );

    return Range(ImageProjectionInclusion(f)[1]);
end
);

#######################################################################
##
#M  IsZero( <f> )
##
##  This function returns true if all the matrices of the homomorphism
##  <f>  are identically zero. 
##
InstallMethod ( IsZero, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f );

    return ForAll(f!.maps, IsZero);
end
);

#######################################################################
##
#M  IsSurjective( <f> )
##
##  This function returns true if the homomorphism  <f>  is surjective. 
##
InstallOtherMethod ( IsSurjective, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    
    local image, dim_image, K, V;

    image := ImagesSet(f,Source(f));
    if Length(image) = 0 then 
        dim_image := 0;
    else
        image := List(image, x -> Flat(ExtRepOfObj(x)![1])); 
        K := LeftActingDomain(Source(f));
        V := K^Length(image[1]);
        dim_image :=  Dimension(Subspace(V,image));
    fi;
    if dim_image = Dimension(Range(f)) then 
        SetIsSurjective(f,true);
        return true;
    else
        SetIsSurjective(f,false);
        return false;
    fi;
end
);

#######################################################################
##
#M  IsIsomorphism( <f> )
##
##  This function returns true if the homomorphism  <f>  is an 
##  isomorphism. 
##
InstallMethod ( IsIsomorphism, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f );

    return IsInjective(f) and IsSurjective(f);
end
);

#######################################################################
##
#O  CoKernelProjection( <f> )
##
##  This function returns a projection from the range of  <f>  to a 
##  module isomorphic to the cokernel of  <f>. 
##
InstallMethod ( CoKernelProjection, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )
    
    local M, N, image, A, K, num_vert, vertices, arrows, basis_list,i, n, v,
          pos, dim_N, V, W, projection, coker, basis_coker, basis_N, a, b,
          mat, mats, source_a, target_a, pos_a, bb, cokermat, C, map, partmap,
          morph, dimvec_coker;

    M := Source(f);
    N := Range(f);
    A := RightActingAlgebra(M);
    K := LeftActingDomain(M); 
    num_vert := Length(VerticesOfQuiver(QuiverOfPathAlgebra(A)));
#
    vertices := List(VerticesOfQuiver(QuiverOfPathAlgebra(A)), x -> x*One(A));
#
# Finding a basis for the vector space in each vertex for the cokernel
#
    image := ImagesSet(f,Source(f));
    basis_list := [];
    for i in [1..Length(vertices)] do
        Add(basis_list,[]);
    od;
    for n in image do
        for v in vertices do
            if n^v <> Zero(N) then
                pos := Position(vertices,v);
                Add(basis_list[pos],ExtRepOfObj(n)![1][pos]);
            fi;
        od;
    od;
    dim_N := DimensionVector(N);
    V := [];    
    W := [];
    projection := [];
    basis_coker := [];   
    basis_N := [];   
    coker := [];
    for i in [1..Length(vertices)] do
        V[i] := K^dim_N[i];
        basis_N[i] := CanonicalBasis(V[i]);
        W[i] := Subspace(V[i],basis_list[i]);
        projection[i] := NaturalHomomorphismBySubspace(V[i],W[i]);
        Add(basis_coker,Basis(Range(projection[i])));
        coker[i] := Range(projection[i]);
    od;
#
# Finding the matrices of the representation of the cokernel 
#
    mats := MatricesOfPathAlgebraModule(N);
    arrows := ArrowsOfQuiver(QuiverOfPathAlgebra(A));
    cokermat := [];
    for a in arrows do
        source_a := Position(vertices,SourceOfPath(a)*One(A));
        target_a := Position(vertices,TargetOfPath(a)*One(A));
        if Length(basis_coker[source_a]) <> 0 and Length(basis_coker[target_a]) <> 0 then
            mat := [];
            pos_a := Position(arrows,a);
            for b in basis_coker[source_a] do
                bb := PreImagesRepresentative(projection[source_a],b);
                bb := bb*mats[pos_a]; # computing bb^a
                Add(mat,Coefficients(basis_coker[target_a],Image(projection[target_a],bb)));
            od;
            Add(cokermat,[String(a),mat]);
        fi;
    od;
    
    dimvec_coker := List(basis_coker, basis -> Length(basis));
    
    if IsPathAlgebra(A) then
        C := RightModuleOverPathAlgebra(A, dimvec_coker, cokermat);
    else
        C := RightModuleOverPathAlgebra(A, dimvec_coker, cokermat);
    fi;
#
# Finding the map for Range(f) to the cokernel 
#
    map := [];
    for i in [1..Length(vertices)] do
        partmap := [];
        if dim_N[i] = 0 then
            partmap := NullMat(1,1,K);
        elif Length(basis_coker[i]) = 0 then 
            partmap := NullMat(dim_N[i],1,K);
        else 
            for b in basis_N[i] do 
                Add(partmap,Coefficients(basis_coker[i],Image(projection[i],b)));
            od;
        fi;
        Add(map,partmap);
    od;
    
    morph := RightModuleHomOverAlgebra(Range(f),C,map);
    SetCoKernelOfWhat(morph,f);
    SetIsSurjective(morph,true);
    
    return morph;
end
);

#######################################################################
##
#O  CoKernelOfAdditiveGeneralMapping( <f> )
##
##  This function returns a module isomorphic to the cokernel of  <f>. 
##
InstallMethod ( CoKernelOfAdditiveGeneralMapping, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    SUM_FLAGS+1,
    function( f )

    return Range(CoKernelProjection(f));
end
);

#######################################################################
##
#A  TopOfModuleProjection( <M> )
##
##  This function computes the map from  M  to the top of  M, 
##  M ---> M/rad(M).
##
InstallMethod( TopOfModuleProjection, 
    "for a pathalgebramatmodule",
    true, 
    [ IsPathAlgebraMatModule ], 0,
    function( M ) 

    local K, A, Q, vertices, num_vert, incomingarrows, mats, arrows, subspaces,
          i, a, dim_M, Vspaces, Wspaces, naturalprojections, index,
          dim_top, matrices, topofmodule, topofmoduleprojection, W;

    A := RightActingAlgebra(M);
    if Dimension(M) = 0 then 
        return ZeroMapping(M,M);
    else
        K := LeftActingDomain(A);
        Q := QuiverOfPathAlgebra(A);
        vertices := VerticesOfQuiver(Q);
        num_vert := Length(vertices);
        incomingarrows := List([1..num_vert], x -> IncomingArrowsOfVertex(vertices[x]));
        mats := MatricesOfPathAlgebraModule(M);
        arrows := ArrowsOfQuiver(Q);
        subspaces := List([1..num_vert], x -> []);
        for i in [1..num_vert] do
            for a in incomingarrows[i] do
                Append(subspaces[i], StructuralCopy(mats[Position(arrows,a)]));
            od;
        od;
        dim_M := DimensionVector(M);
        Vspaces := List([1..num_vert], x -> FullRowSpace(K,dim_M[x]));
        Wspaces := List([1..num_vert], x -> []);
        for i in [1..num_vert] do
            if dim_M[i] <> 0 then 
                Wspaces[i] := Subspace(Vspaces[i],subspaces[i]);
            else
                Wspaces[i] := Subspace(Vspaces[i],[]);
            fi;
        od;
        naturalprojections := List([1..num_vert], x -> NaturalHomomorphismBySubspace(Vspaces[x],Wspaces[x]));
        dim_top := List([1..num_vert], x -> Dimension(Range(naturalprojections[x]))); 
        index := function( n )
            if n = 0 then 
                return 1;
            else
                return n;
            fi;
        end;
        matrices := [];
        for i in [1..num_vert] do
            if dim_top[i] <> 0 then
                Add(matrices, List(BasisVectors(Basis(Vspaces[i])), y -> ImageElm(naturalprojections[i],y)));
            else
                Add(matrices, NullMat(index(dim_M[i]),1,K));
            fi;
        od;
        topofmodule := RightModuleOverPathAlgebra(A,dim_top,[]);
        topofmoduleprojection := RightModuleHomOverAlgebra(M,topofmodule,matrices);

        SetTopOfModule(M,topofmodule);

        return topofmoduleprojection;
    fi;
end
);

#######################################################################
##
#A  TopOfModule( <M> )
##
##  This function computes the top  M/rad(M)  of the module M. 
##
InstallMethod( TopOfModule, 
    "for a pathalgebramatmodule",
    true, 
    [ IsPathAlgebraMatModule ], 0,
    function( M )

    return Range(TopOfModuleProjection(M));
end
);

InstallOtherMethod ( TopOfModule, 
"for a PathAlgebraMatModuleMap",
[ IsPathAlgebraMatModuleHomomorphism ],
function( f )
    
  local M, N, K, pi_M, pi_N, BTopM, dim_vector_TopM, dim_vector_TopN, 
        n, h, i, dim, matrix, j, b, btilde, bprime;
  
  M := Source( f );
  N := Range( f );
  K := LeftActingDomain( M );
  pi_M := TopOfModuleProjection( M );
  pi_N := TopOfModuleProjection( N );
  BTopM := BasisVectors( Basis( Range( pi_M ) ) );
  dim_vector_TopM := DimensionVector( Range( pi_M ) );
  dim_vector_TopN := DimensionVector( Range( pi_N ) );    
  n := Length( dim_vector_TopM ); 
  h := [ ];
  for i in [ 1..n ] do
    if dim_vector_TopM[ i ] > 0 then
      if dim_vector_TopN[ i ] = 0 then
        Add( h, NullMat( dim_vector_TopM[ i ], 1, K ) );
      else
#
# Assuming that the basisvectors of topM are listed as 
# first basisvectors for vertex 1, vertex 2, .....
#
        dim := Sum( dim_vector_TopM{ [ 1..i - 1 ] } );
        matrix := [ ];
        for j in [ 1..dim_vector_TopM[ i ] ] do
          b := BTopM[ dim + j ];
          btilde := PreImagesRepresentative( pi_M, b );
          bprime := ImageElm( pi_N, ImageElm( f, btilde ) );
          Add( matrix, ExtRepOfObj( ExtRepOfObj( bprime ) )[ i ] ); 
        od;
        Add( h, matrix );
      fi;
    else
      if dim_vector_TopN[ i ] = 0 then
        Add( h, NullMat( 1, 1, K ) );
      else
        Add( h, NullMat( 1, dim_vector_TopN[ i ], K ) );
      fi;
    fi;        
  od;
  
  return RightModuleHomOverAlgebra( Range( pi_M ), Range( pi_N ), h );
end
  );

#######################################################################
##
#M  \+( <f>, <g> )
##
##  This function returns the sum of two homomorphisms  <f>  and  <g>,
##  when the sum is defined, otherwise it returns an error message. 
##
InstallMethod( \+,
    "for two PathAlgebraMatModuleMap's",
    true,
#  IsIdenticalObj,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f, g )
    
    local i, num_vert, x, Fam;

    if ( Source(f) = Source(g) ) and ( Range(f) = Range(g) ) then 
      num_vert := Length(f!.maps);
        x := List([1..num_vert], y -> f!.maps[y] + g!.maps[y]);
        return RightModuleHomOverAlgebra(Source(f),Range(f),x);
    else
 Error("the two arguments entered do not live in the same homomorphism set, ");
    fi;
end
);
  
#######################################################################
##
#M  \*( <f>, <g> )
##
##  This function returns the composition  <f*g>  of two homomorphisms  
##  <f>  and  <g>, that is, first the map  <f> then followed by  <g>,  
##  when the composition is defined, otherwise it returns an error 
##  message. 
##
InstallMethod( \*,
    "for two PathAlgebraMatModuleMap's",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f, g )
    
    local i, num_vert, x;

    if Range(f) = Source(g) then 
      num_vert := Length(f!.maps);
        x := List([1..num_vert], y -> f!.maps[y]*g!.maps[y]);
 return RightModuleHomOverAlgebra(Source(f),Range(g),x);
    else
        Error("codomain of the first argument is not equal to the domain of the second argument, ");
    fi;
end
);
  
#######################################################################
##
#M  \*( <a>, <g> )
##
##  This function returns the scalar multiple  <a*g>  of a scalar  <a> 
##  with a homomorphism <g>, when this scalar multiplication is defined, 
##  otherwise it returns an error message. 
##
InstallOtherMethod( \*,
    "for two PathAlgebraMatModuleMap's",
    true,
    [ IsScalar, IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( a, g )
    
    local K, i, num_vert, x;

    K := LeftActingDomain(Source(g));
    if a in K then 
      num_vert := Length(g!.maps);
        x := List([1..num_vert], y -> a*g!.maps[y]);
        return RightModuleHomOverAlgebra(Source(g),Range(g),x);
     else
         Error("the scalar is not in the same field as the algbra is over,");
     fi;
end
);
  
#######################################################################
##
#M  AdditiveInverseOp( <f> )
##
##  This function returns the additive inverse of the homomorphism 
##  <f>. 
##
InstallMethod( AdditiveInverseOp,
    "for a morphism in IsPathAlgebraMatModuleHomomorphism",
    [ IsPathAlgebraMatModuleHomomorphism ],

    function ( f ) 

    local i, num_vert, x;

    num_vert := Length(f!.maps);
    x := List([1..num_vert], y -> (-1)*f!.maps[y]);

    return RightModuleHomOverAlgebra(Source(f),Range(f),x);
end
);

#######################################################################
##
#M  \*( <f>, <a> )
##
##  This function returns the scalar multiple  <f*a>  of a homomorphism
##  <f>  and a scalar  <a>. 
##
InstallOtherMethod( \*,
    "for two PathAlgebraMatModuleMap's",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsScalar ],
    0,
    function( f, a )
    
    local K, i, num_vert, x;

    K := LeftActingDomain(Source(f));
    if a in K then 
      num_vert := Length(f!.maps);
        x := List([1..num_vert], y -> f!.maps[y]*a);
 return RightModuleHomOverAlgebra(Source(f),Range(f),x);
    else
  Error("the scalar is not in the same field as the algbra is over,");
    fi;
end
);
  
#######################################################################
##
#O  HomOverAlgebra( <M>, <N> )
##
##  This function computes a basis of the vector space of homomorphisms
##  from the module  <M>  to the module  <N>. The algorithm it uses is
##  based purely on linear algebra.
##
InstallMethod( HomOverAlgebra,
    "for two representations of a quiver",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
    function( M, N )

    local A, F, dim_M, dim_N, num_vert, support_M, support_N, num_rows, num_cols, 
          block_rows, block_cols, block_intervals, 
          i, j, equations, arrows, vertices, v, a, source_arrow, target_arrow, 
          mats_M, mats_N, prev_col, prev_row, row_start_pos, col_start_pos, 
          row_end_pos, col_end_pos, l, m, n, hom_basis, map, mat, homs, x, y, k, b, 
          dim_hom, zero;

    A := RightActingAlgebra(M); 
    if A <> RightActingAlgebra(N) then
        Print("The two modules entered are not modules over the same algebra.");
        return fail;
    fi;
    F := LeftActingDomain(A);
    #
    # Finding the support of M and N
    # 
    vertices := VerticesOfQuiver(QuiverOfPathAlgebra(OriginalPathAlgebra(A)));
    dim_M := DimensionVector(M);
    dim_N := DimensionVector(N);
    num_vert := Length(dim_M);   
    support_M := [];
    support_N := [];
    for i in [1..num_vert] do
        if (dim_M[i] <> 0) then 
            AddSet(support_M,i);
        fi;
        if (dim_N[i] <> 0) then 
            AddSet(support_N,i);
        fi;
    od;
    #
    # Deciding the size of the equations, 
    # number of columns and rows
    #
    num_cols := 0;
    num_rows := 0;
    block_intervals := [];
    block_rows := [];
    block_cols := [];
    prev_col := 0;
    prev_row := 0;
    for i in support_M do
        num_rows := num_rows + dim_M[i]*dim_N[i];
        block_rows[i] := prev_row+1;
        prev_row := num_rows;
        for a in OutgoingArrowsOfVertex(vertices[i]) do
            source_arrow := Position(vertices,SourceOfPath(a));
            target_arrow := Position(vertices,TargetOfPath(a));
            if (target_arrow in support_N) and ( (source_arrow in support_N) or (target_arrow in support_M)) then 
                num_cols := num_cols + dim_M[source_arrow]*dim_N[target_arrow];
                Add(block_cols,[a,prev_col+1,num_cols]);
            fi;
            prev_col := num_cols; 
        od;
    od;
    #
    # Finding the linear equations for the maps between M and N
    #
    equations := NullMat(num_rows, num_cols, F);

    arrows := ArrowsOfQuiver(QuiverOfPathAlgebra(OriginalPathAlgebra(A)));
    mats_M := MatricesOfPathAlgebraModule(M);
    mats_N := MatricesOfPathAlgebraModule(N);
    prev_col := 0;
    prev_row := 0;
    for i in support_M do
        for a in OutgoingArrowsOfVertex(vertices[i]) do
            source_arrow := Position(vertices,SourceOfPath(a));
            target_arrow := Position(vertices,TargetOfPath(a));
            if (target_arrow in support_N) and ( (source_arrow in support_N) or (target_arrow in support_M)) then
                for j in [1..dim_M[source_arrow]] do
                    row_start_pos := block_rows[source_arrow] + (j-1)*dim_N[source_arrow]; 
                    row_end_pos := block_rows[source_arrow] - 1 + j*dim_N[source_arrow];
                    col_start_pos := prev_col + 1 + (j-1)*dim_N[target_arrow];
                    col_end_pos := prev_col + j*dim_N[target_arrow];
                    if (source_arrow in support_N) then 
                        equations{[row_start_pos..row_end_pos]}{[col_start_pos..col_end_pos]} := mats_N[Position(arrows,a)];
                    fi;
                    if (target_arrow in support_M) then 
                        for m in [1..DimensionsMat(mats_M[Position(arrows,a)])[2]] do
                            for n in [1..dim_N[target_arrow]] do
                                b := block_rows[target_arrow]+(m-1)*dim_N[target_arrow];
                                equations[b+n-1][col_start_pos+n-1] := equations[b+n-1][col_start_pos+n-1]+(-1)*mats_M[Position(arrows,a)][j][m];
                            od;
                        od;
                    fi;
                od;
                prev_col := prev_col + dim_M[source_arrow]*dim_N[target_arrow];
            fi;
        od;
    od;
    #
    # Creating the maps between the module M and N
    #
    homs := [];
    if (num_rows <> 0) and (num_cols <> 0) then 
        dim_hom := 0; 
        hom_basis := NullspaceMat(equations);
        for b in hom_basis do
            map := [];
            dim_hom := dim_hom + 1;
            k := 1;
            for i in [1..num_vert] do 
                if dim_M[i] = 0 then 
                    if dim_N[i] = 0 then 
                        Add(map,NullMat(1,1,F));
                    else
                        Add(map,NullMat(1,dim_N[i],F));
                    fi;
                else
                    if dim_N[i] = 0 then 
                        Add(map,NullMat(dim_M[i],1,F));
                    else
                        mat := NullMat(dim_M[i],dim_N[i], F);
                        for y in [1..dim_M[i]] do 
                            for x in [1..dim_N[i]] do 
                                mat[y][x] := b[k];
                                k := k + 1;
                            od;
                        od;
                        Add(map,mat);
                    fi;
                fi;
            od;
            homs[dim_hom] := Objectify( NewType( CollectionsFamily( GeneralMappingsFamily(
                                     ElementsFamily( FamilyObj( M ) ),
                                     ElementsFamily( FamilyObj( N ) ) ) ), 
                                     IsPathAlgebraMatModuleHomomorphism and IsPathAlgebraMatModuleHomomorphismRep and IsAttributeStoringRep ), rec( maps := map ));
            SetPathAlgebraOfMatModuleMap(homs[dim_hom], A);
            SetSource(homs[dim_hom], M);
            SetRange(homs[dim_hom], N);
            SetIsWholeFamily(homs[dim_hom],true);
        od;
        return homs;
    else
        homs := [];
        if Dimension(M) = 0 or Dimension(N) = 0 then 
            return homs;
        else 
            dim_hom := 0;
            zero := [];
            for i in [1..num_vert] do
                if dim_M[i] = 0 then 
                    if dim_N[i] = 0 then 
                        Add(zero,NullMat(1,1,F));
                    else
                        Add(zero,NullMat(1,dim_N[i],F));
                    fi;
                else
                    if dim_N[i] = 0 then 
                        Add(zero,NullMat(dim_M[i],1,F));
                    else
                        Add(zero,NullMat(dim_M[i],dim_N[i],F));
                    fi;
                fi;
            od;      
            for i in [1..num_vert] do
                if (dim_M[i] <> 0) and (dim_N[i] <> 0) then 
                    for m in BasisVectors(Basis(FullMatrixSpace(F,dim_M[i],dim_N[i]))) do
                        dim_hom := dim_hom + 1;
                        homs[dim_hom] := ShallowCopy(zero);
                        homs[dim_hom][i] := m;
                    od;
                fi;
            od;
            for i in [1..dim_hom] do 
                homs[i] := Objectify( NewType( CollectionsFamily( GeneralMappingsFamily(
                                   ElementsFamily( FamilyObj( M ) ),
                                   ElementsFamily( FamilyObj( N ) ) ) ), 
                                   IsPathAlgebraMatModuleHomomorphism and IsPathAlgebraMatModuleHomomorphismRep and IsAttributeStoringRep ), rec( maps := homs[i] ));
                SetPathAlgebraOfMatModuleMap(homs[i], A);
                SetSource(homs[i], M);
                SetRange(homs[i], N);
                SetIsWholeFamily(homs[i],true);
            od;

            return homs;
        fi;
    fi;
end
);

#######################################################################
##
#O  HomOverAlgebraWithBasisFunction( <M>, <N> )
##
##  This function returns a list with two entries. The first entry is 
##  a basis of the vector space of homomorphisms from the module  <M>
##  to the module  <N>.  The second entry is a function from the space 
##  of homomorphisms from  <M>  to  <N>  to the vector space with the 
##  given by the first entry.  The algorithm it uses is based purely 
##  on linear algebra.
##
InstallMethod( HomOverAlgebraWithBasisFunction,
    "for two representations of a quiver",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
    function( M, N )

    local homs, F, basis, V, W, HomB, transfermat, coefficients;


    homs := HomOverAlgebra( M, N );
    F := LeftActingDomain( RightActingAlgebra( M ) );
    
    if Length( homs ) > 0 then
      basis := List( homs, h -> Flat( h!.maps ) );
      V := FullRowSpace( F, Length( basis[ 1 ] ) );
      W := Subspace( V, basis, "basis" );
      HomB := Basis( W );
      transfermat := List( basis, b -> Coefficients( HomB, b ) );
      coefficients := function( h )
        local hflat, coeff;
               
        hflat := Flat( h!.maps );
        coeff := Coefficients( HomB, hflat );
        
        return coeff * transfermat^(-1);
      end;
    else
      coefficients := function( h );
        return [ Zero( F ) ];
      end;
    fi;
    
    return [ homs, coefficients ];
end
);

#######################################################################
##
#A  EndOverAlgebra( <M>, <N> )
##
##  This function computes endomorphism ring of the module  <M>  and
##  representing it as an general GAP algebra. The algorithm it uses is
##  based purely on linear algebra.
##
InstallMethod( EndOverAlgebra,
    "for a representations of a quiver",
    [ IsPathAlgebraMatModule ], 0,
    function( M )

    local EndM, R, F, dim_M, alglist, i, j, r, maps, A; 

    EndM := HomOverAlgebra(M,M);
    R := RightActingAlgebra(M); 
    F := LeftActingDomain(R);
    dim_M := DimensionVector(M);
    alglist := [];
    for i in [1..Length(dim_M)] do 
        if dim_M[i] <> 0 then 
            Add(alglist, MatrixAlgebra(F,dim_M[i]));
        fi;
    od;
    maps := [];
    for i in [1..Length(EndM)] do
        maps[i] := NullMat(Dimension(M),Dimension(M),F);
        r := 1; 
        for j in [1..Length(dim_M)] do 
            if dim_M[j] <> 0 then 
                maps[i]{[r..r+dim_M[j]-1]}{[r..r+dim_M[j]-1]} := EndM[i]!.maps[j];
            fi;
            r := r + dim_M[j];
        od; 
    od;
    A := DirectSumOfAlgebras(alglist); 
    
    return SubalgebraWithOne(A,maps,"basis"); 
end
);

#######################################################################
##
#A  RightFacApproximation( <M>, <C> )
##
##  This function computes a right Fac<M>-approximation of the module 
##  <C>. 
##
InstallMethod( RightFacApproximation,
    "for a representations of a quiver",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
    function( M, C )

    local homMC, i, generators; 

    homMC := HomOverAlgebra(M,C); 
    generators := [];
    for i in [1..Length(homMC)] do
        Append(generators,ImagesSet(homMC[i],Source(homMC[i])));
    od;
    
    return SubRepresentationInclusion(C,generators);
end
);

#######################################################################
##
#O  NumberOfNonIsoDirSummands( <M> )
##
##  This function computes the number of non-isomorphic indecomposable 
##  direct summands of the module  <M>, and in addition returns the 
##  dimensions of the simple blocks of the semisimple ring  
##  End(M)/rad End(M). 
##
InstallMethod( NumberOfNonIsoDirSummands,
    "for a representations of a quiver",
    [ IsPathAlgebraMatModule ], 0,
    function( M )
 
    local EndM, K, J, gens, I, A, top, AA, B, n,
          i, j, genA, V, W, d;

    EndM := EndOverAlgebra(M);
    K := LeftActingDomain(M);
    J := RadicalOfAlgebra(EndM);
    gens := GeneratorsOfAlgebra(J);
    I := Ideal(EndM,gens); 
    A := EndM/I;
    top := CentralIdempotentsOfAlgebra(A);
    
    return [Length(top),List(DirectSumDecomposition(EndM/I),Dimension)];
end
);

#######################################################################
##
#A  DualOfModuleHomomorphism( <f> )
##
##  This function computes the dual of a homomorphism from the module  
##  <M>  to the module  <N>.
##
InstallMethod ( DualOfModuleHomomorphism,
    "for a map between representations of a quiver",
    [ IsPathAlgebraMatModuleHomomorphism ], 0,
    function( f )

    local mats, M, N;
   
    mats := f!.maps;
    mats := List(mats, x -> TransposedMat(x));
    M := DualOfModule(Source(f));
    N := DualOfModule(Range(f));

    return RightModuleHomOverAlgebra(N,M,mats);
end
);

#######################################################################
##
#A  SocleOfModuleInclusion( <M> )
##
##  This function computes the map from the socle of  M  to the module M, 
##  soc(M) ---> M.
##
InstallMethod( SocleOfModuleInclusion, 
    "for a pathalgebramatmodule",
    true, 
    [ IsPathAlgebraMatModule ], 0,
    function( M )

    local A, K, Q, vertices, num_vert, outgoingarrows, mats, arrows, dim_M, 
          subspaces, i, a, j, socle, matrixfunction, dim_socle, socleofmodule, 
          socleinclusion, V, temp;

    A := RightActingAlgebra(M);
    if Dimension(M) = 0 then 
        return ZeroMapping(M,M);
    else
        K := LeftActingDomain(A);
        Q := QuiverOfPathAlgebra(A);
        vertices := VerticesOfQuiver(Q);
        num_vert := Length(vertices);
        outgoingarrows := List([1..num_vert], x -> OutgoingArrowsOfVertex(vertices[x]));
        dim_M := DimensionVector(M);
        mats := MatricesOfPathAlgebraModule(M);
        arrows := ArrowsOfQuiver(Q);
        dim_socle := List([1..num_vert], x -> 0);
        socle := List([1..num_vert], x -> []);
        for i in [1..num_vert] do
            if ( Length(outgoingarrows[i]) = 0 ) or ( dim_M[i] = 0 ) then
                dim_socle[i] := dim_M[i];
                if  dim_M[i] = 0 then
                    socle[i] := NullMat(1,1,K);
                else
                    socle[i] := IdentityMat(dim_M[i],K);
                fi;
            else
                subspaces := List([1..dim_M[i]], y -> []);   
                for a in outgoingarrows[i] do
                    for j in [1..dim_M[i]] do
                        Append(subspaces[j], StructuralCopy(mats[Position(arrows,a)][j]));
                    od;
                od;
                V := FullRowSpace(K,dim_M[i]);
                temp := NullspaceMat(subspaces);
                dim_socle[i] := Dimension(Subspace(V,temp));
                if dim_socle[i] = 0 then
                    socle[i] := NullMat(1,dim_M[i],K);
                else
                    socle[i] := temp;
                fi;
            fi;
        od;
        socleofmodule := RightModuleOverPathAlgebra(A,dim_socle,[]);
        socleinclusion := RightModuleHomOverAlgebra(socleofmodule,M,socle);
#        SetSocleOfModule(M,socleofmodule);
        return socleinclusion;
    fi;
end
  );

#######################################################################
##
#A  SocleOfModule( <M> )
##
##  This function computes the socle  soc(M)  of the module M. 
##
InstallMethod( SocleOfModule, 
    "for a pathalgebramatmodule",
    true, 
    [ IsPathAlgebraMatModule ], 0,
    function( M )

    return Source(SocleOfModuleInclusion(M));
end
);

#######################################################################
##
#O  CommonDirectSummand( <M>, <N> )
##
##  This function is using the algorithm for finding a common direct 
##  summand presented in the paper "Gauss-Elimination und der groesste
##  gemeinsame direkte Summand von zwei endlichdimensionalen Moduln"
##  by K. Bongartz, Arch Math., vol. 53, 256-258, with the modification
##  done by Andrzej Mroz found in "On the computational complexity of Bongartz's
##  algorithm" (improving the complexity of the algorithm).
##
InstallMethod( CommonDirectSummand, 
    "for two path algebra matmodules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule  ], 0,
    function( M, N ) 

    local   HomMN,  HomNM,  mn,  nm,  m,  n,  l,  zero,  j,  i,  temp,  
          r,  f,  fnm,  nmf;

    if RightActingAlgebra( M ) <> RightActingAlgebra( N ) then 
        Print( "The two modules are not modules over the same algebra.\n" );
        return fail;
    else
        HomMN := HomOverAlgebra( M, N );
        HomNM := HomOverAlgebra( N, M );
        mn := Length( HomMN );
        nm := Length( HomNM );
      
        if mn = 0 or nm = 0 then 
            return false;
        fi;
      
        m := Maximum( DimensionVector( M ) );
        n := Maximum( DimensionVector( N ) );
        if n = m then
            l := n;
        else
            l := Minimum( [ n, m ] ) + 1;
        fi;
        
        n := Int( Ceil( Log2( 1.0*( l ) ) ) );
          
        zero := ZeroMapping( M, M );
      
        for j in [ 1..nm ] do
            for i in [ 1..mn ] do
                if l > 1 then  # because hom^0 * hom => error! 
                    temp := HomMN[ i ] * HomNM[ j ];
                    for r in [ 1..n ] do
                        temp := temp * temp;
                    od;
                    f := temp * HomMN[ i ];
                else 
                    f := HomMN[ i ];
                fi;
                
                fnm := f * HomNM[ j ];
              
                if fnm <> zero then
                    nmf := HomNM[ j ] * f; 
                    return [ Image( fnm ), Kernel( fnm ), Image( nmf ), Kernel( nmf ) ];
                fi;
            od;
        od;

        return false;
    fi; 
end
);

#######################################################################
##
#O  MaximalCommonDirectSummand( <M>, <N> )
##
##  This function is using the algorithm for finding a maximal common 
##  direct summand based on the algorithm presented in the paper 
##  "Gauss-Elimination und der groesste gemeinsame direkte Summand von 
##  zwei endlichdimensionalen Moduln" by K. Bongartz, Arch Math., 
##  vol. 53, 256-258, with the modification done by Andrzej Mroz found 
##  in "On the computational complexity of Bongartz's algorithm" 
##  (improving the complexity of the algorithm).
##
InstallMethod( MaximalCommonDirectSummand, 
    "for two path algebra matmodules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule  ], 0,
    function( M, N ) 

    local U, V, maxcommon, L;

    U := M;
    V := N;
    maxcommon := [];
    repeat 
        L := CommonDirectSummand(U,V);
        if L <> false and L <> fail then 
            Add(maxcommon,L[1]);
            U := L[2];
            V := L[4];
            if Dimension(L[2]) = 0 or Dimension(L[4]) = 0 then
                break;
            fi;
        fi;
    until  L = false or L = fail;
    
    if Length(maxcommon) = 0 then 
        return false;
    else 
        return [maxcommon,U,V];
    fi;     
end
);

#######################################################################
##
#O  IsomorphicModules( <M>, <N> )
##
##  This function returns true if the modules  <M>  and  <N>  are 
##  isomorphic, an error message if  <M>  and  <N>  are not modules over 
##  the same algebra and false otherwise.
##  
InstallMethod( IsomorphicModules, 
    "for two path algebra matmodules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule  ], 0,
    function( M, N ) 

    local L;

    if DimensionVector(M) <> DimensionVector(N) then 
        return false;
    elif Dimension(M) = 0 and Dimension(N) = 0 then 
        return true; 
    else 
        L := MaximalCommonDirectSummand(M,N);
        if L = false then 
            return false;
        else
            if Dimension(L[2]) = 0 and Dimension(L[3]) = 0 then 
                return true;
            else
                return false;
            fi;
        fi;
    fi;
end
); 

#######################################################################
##
#O  IsDirectSummand( <M>, <N> )
##
##  This function returns true if the module  <M>  is isomorphic to a 
##  direct of the module  <N>, an error message if  <M>  and  <N>  are 
##  not modules over the same algebra and false otherwise.
##  
InstallMethod( IsDirectSummand, 
    "for two path algebra matmodules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule  ], 0,
    function( M, N ) 

    local L;

    if not DimensionVectorPartialOrder(M,N) then 
        return false;
    else 
        L := MaximalCommonDirectSummand(M,N);
        if L = false then 
            return false;
        else 
            if Dimension(L[2]) = 0 then 
                return true;
            else
                return false;
            fi;
        fi;
    fi;
end
); 

#######################################################################
##
#O  IsInAdditiveClosure( <M>, <N> )
##
##  This function returns true if the module  <M>  is in the additive
##  closure of the module  <N>, an error message if  <M>  and  <N>  are 
##  not modules over the same algebra and false otherwise.
##
InstallMethod( IsInAdditiveClosure, 
    "for two path algebra matmodules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule  ], 0,
    function( M, N ) 

    local K, HomMN, HomNM, MM, i, j, HomMM, V_M;

    if RightActingAlgebra(M) <> RightActingAlgebra(N) then 
        return fail;
    else
#
# Computing Hom(M,N) and Hom(N,M), finding the subspace in Hom(M,M)
# spanned by Hom(M,N)*Hom(M,N), if they have the same dimension, then 
# the identity on  M  is in the linear span of Hom(M,N)*Hom(M,N) and  
# module M is in the additive closure of N. 
#
        K := LeftActingDomain(M);
        HomMN := HomOverAlgebra(M,N);
        HomNM := HomOverAlgebra(N,M);
        MM := [];
        for i in [1..Length(HomMN)] do
            for j in [1..Length(HomNM)] do
                Add(MM,HomMN[i]*HomNM[j]);
            od;
        od;
        MM := List(MM,x->x!.maps);
        for i in [1..Length(MM)] do
            MM[i] := List(MM[i],x->Flat(x)); 
            MM[i] := Flat(MM[i]);
        od;
        HomMM:=HomOverAlgebra(M,M);
        if Length(MM) = 0 then 
            V_M := TrivialSubspace(K);
        else 
            V_M := VectorSpace(K,MM);
        fi; 
        if Dimension(V_M) = Length(HomOverAlgebra(M,M)) then
            return true;
        else
            return false;
        fi;
    fi;
end
);

#######################################################################
##
#O  MorphismOnKernel( <f>, <g>, <beta>, <alpha> )
##
##  Given the following commutative diagram
##          B -- f --> C
##          |          |
##     beta |          | alpha
##          V          V 
##          B' - g --> C' 
##  this function finds the induced homomorphism on the kernels of 
##  f and g. 
##
InstallMethod ( MorphismOnKernel, 
    "for commutative diagram of PathAlgebraMatModuleMaps",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g, beta, alpha )

    local K, kerf, kerg, B, dim_vec_kerf, dim_vec_kerg, map, j, i, p, mat;
#
#  Checking if a commutative diagram was entered
# 
    if f*alpha = beta*g then 
# 
#
        K := LeftActingDomain(Source(f));
        kerf := KernelInclusion(f);
        kerg := KernelInclusion(g);
#
#  Computing the information needed for lifting the morphism.
#
        B := BasisVectors(Basis(Source(kerf)));
        B := List(B, x -> ImageElm(kerf*beta,x));
        B := List(B, x -> PreImagesRepresentative(kerg,x));
#
#  Computing dimension vectors so that we can insert zero matrices of 
#  the right size. 
#
        dim_vec_kerf := DimensionVector(Source(kerf));
        dim_vec_kerg := DimensionVector(Source(kerg));
        map := [];
        j := 0;
        for i in [1..Length(dim_vec_kerf)] do
#
#  If the kernel of  f  is zero in vertex  i, then insert a zero matrix of
#  the right size, do not use any of the lifting information.
# 
            if dim_vec_kerf[i] = 0 then
                if  dim_vec_kerg[i] = 0 then 
                    Add(map,NullMat(1,1,K));
                else
                    Add(map,NullMat(1,dim_vec_kerg[i],K));
                fi;
            else
#
#  If the kernel of  f  is non-zero in vertex  i, then use the lifting 
#  information to compute the right matrix for the map from vertex  i  to  i.
# 
                mat := [];
                for p in [1..dim_vec_kerf[i]] do
                    j := j + 1;
                    Add(mat,ExtRepOfObj(ExtRepOfObj(B[j]))[i]);
                od;
                Add(map,mat);
            fi;
        od;
        return RightModuleHomOverAlgebra(Source(kerf),Source(kerg),map);
    else 
       return fail;
    fi;
end
);

#######################################################################
##
#O  MorphismOnImage( <f>, <g>, <beta>, <alpha> )
##
##  Given the following commutative diagram
##          B -- f --> C
##          |          |
##     beta |          | alpha
##          V          V 
##          B' - g --> C' 
##  this function finds the induced homomorphism on the images of 
##  f and g. 
##
InstallMethod ( MorphismOnImage, 
    "for commutative diagram of PathAlgebraMatModuleMaps",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g, beta, alpha )

    local K, imagef, imageg, B, dim_vec_imagef, dim_vec_imageg, map, j, i, p, mat;
#
#  Checking if a commutative diagram was entered
# 
    if f*alpha = beta*g then 
# 
#
        K := LeftActingDomain(Source(f));
        imagef := ImageProjection(f);
        imageg := ImageProjection(g);
#
#  Computing the information needed for lifting the morphism.
#
        B := BasisVectors(Basis(Range(imagef)));
        B := List(B, x -> PreImagesRepresentative(imagef,x));
        B := List(B, x -> ImageElm(beta*imageg,x));
#
#  Computing dimension vectors so that we can insert zero matrices of 
#  the right size. 
#
        dim_vec_imagef := DimensionVector(Range(imagef));
        dim_vec_imageg := DimensionVector(Range(imageg));
        map := [];
        j := 0;
        for i in [1..Length(dim_vec_imagef)] do
#
#  If the image of  f  is zero in vertex  i, then insert a zero matrix of
#  the right size, do not use any of the lifting information.
# 
            if dim_vec_imagef[i] = 0 then
                if  dim_vec_imageg[i] = 0 then 
                    Add(map,NullMat(1,1,K));
                else
                    Add(map,NullMat(1,dim_vec_imageg[i],K));
                fi;
            else
#
#  If the cokernel of  f  is non-zero in vertex  i, then use the lifting 
#  information to compute the right matrix for the map from vertex  i  to  i.
# 
                mat := [];
                for p in [1..dim_vec_imagef[i]] do
                    j := j + 1;
                    Add(mat,ExtRepOfObj(ExtRepOfObj(B[j]))[i]);
                od;
                Add(map,mat);
            fi;
        od;
        return RightModuleHomOverAlgebra(Range(imagef),Range(imageg),map);
    else 
        return fail;
    fi;
end
);

#######################################################################
##
#O  MorphismOnCoKernel( <f>, <g>, <beta>, <alpha> )
##
##  Given the following commutative diagram
##          B -- f --> C
##          |          |
##     beta |          | alpha
##          V          V 
##          B' - g --> C' 
##  this function finds the induced homomorphism on the cokernels of 
##  f and g. 
##
InstallMethod ( MorphismOnCoKernel, 
    "for commutative diagram of PathAlgebraMatModuleMaps",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g, beta, alpha )

    local K, cokerf, cokerg, B, dim_vec_cokerf, dim_vec_cokerg, map, j, i, p, mat;
#
#  Checking if a commutative diagram was entered
# 
    if f*alpha = beta*g then 
# 
#
        K := LeftActingDomain(Source(f));
        cokerf := CoKernelProjection(f);
        cokerg := CoKernelProjection(g);
#
#  Computing the information needed for lifting the morphism.
#
        B := BasisVectors(Basis(Range(cokerf)));
        B := List(B, x -> PreImagesRepresentative(cokerf,x));
        B := List(B, x -> ImageElm(alpha*cokerg,x));
#
#  Computing dimension vectors so that we can insert zero matrices of 
#  the right size. 
#
        dim_vec_cokerf := DimensionVector(Range(cokerf));
        dim_vec_cokerg := DimensionVector(Range(cokerg));
        map := [];
        j := 0;
        for i in [1..Length(dim_vec_cokerf)] do
#
#  If the cokernel of  f  is zero in vertex  i, then insert a zero matrix of
#  the right size, do not use any of the lifting information.
# 
            if dim_vec_cokerf[i] = 0 then
                if  dim_vec_cokerg[i] = 0 then 
                    Add(map,NullMat(1,1,K));
                else
                    Add(map,NullMat(1,dim_vec_cokerg[i],K));
                fi;
            else
#
#  If the cokernel of  f  is non-zero in vertex  i, then use the lifting 
#  information to compute the right matrix for the map from vertex  i  to  i.
# 
                mat := [];
                for p in [1..dim_vec_cokerf[i]] do
                    j := j + 1;
                    Add(mat,ExtRepOfObj(ExtRepOfObj(B[j]))[i]);
                od;
                Add(map,mat);
            fi;
        od;
        return RightModuleHomOverAlgebra(Range(cokerf),Range(cokerg),map);
    else 
        return fail;
    fi;
end
);


#######################################################################
##
#O  LiftingMorphismFromProjective( <f>, <g> )
##
##  Given the following diagram
##                P
##                |
##                | g
##            f   V 
##        B ----> C 
##  where  P  is a direct sum of indecomposable projective modules 
##  constructed via DirectSumOfQPAModules and  f  an epimorphism, 
##  this function finds a lifting of  g  to  B.
##
InstallMethod ( LiftingMorphismFromProjective, 
    "for two PathAlgebraMatModuleMaps",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g )

    local P, K, B, inclusions, projections, i, m, hmap; 
#
#  Checking if the input is as required
# 
    P := Source(g);
    if not IsProjectiveModule(P) then
        Error( "The source of the second map is not projective.\n" );
    fi;
    if not IsSurjective(f) then
        Error( "The first map is not surjective.\n" );        
    fi;
    if not ( Range(f) = Range(g) ) then
        Error( "The entered maps do not have a common range.\n" );
    fi;
    if IsZero( P ) then
        return ZeroMapping( P, Source( f ) );
    fi;
    if IsDirectSumOfModules(P) then     
#   
#
        K := LeftActingDomain(P);
        inclusions  := DirectSumInclusions(P);
        projections := DirectSumProjections(P);
        hmap := [];
#
#  First construct the lifting from each indecomposable direct summand of  P.
# 
        for i in [1..Length(inclusions)] do
            m := MinimalGeneratingSetOfModule(Source(inclusions[i]))[1];
            if ImageElm(g,ImageElm(inclusions[i],m)) = Zero(Range(g)) then 
                Add(hmap,ZeroMapping(Source(inclusions[i]),Source(f)));
            else 
                m := PreImagesRepresentative(f,ImageElm(g,ImageElm(inclusions[i],m)));
                Add(hmap,HomFromProjective(m,Source(f)));
            fi;
        od;
#
#  Make sure that the partial liftings start in the right modules/variables. 
#
        hmap := List([1..Length(inclusions)], x -> RightModuleHomOverAlgebra(Source(inclusions[x]),Source(f),hmap[x]!.maps));
        return projections*hmap;
    else 
        return fail;
    fi;
end
);

#######################################################################
##
#O  LiftingInclusionMorphisms( <f>, <g> )
##
##  Given the following diagram
##                A
##                |
##                | g
##            f   V 
##        B ----> C 
##  where  f  and  g  are inclusions, this function constructs a 
##  morphism (inclusion) from  A  to  B, whenever the image of  g  is
##  contained in the image of  f.  Otherwise the function returns fail.
##
InstallMethod ( LiftingInclusionMorphisms, 
    "for two PathAlgebraMatModuleMaps",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g )

    local pi, K, B, dim_vec_sourcef, dim_vec_sourceg, map, i, j, mat, p; 
#
#  Checking if the image of  g  is contained in the image of  f.
# 
    pi := CoKernelProjection(f);
    if ( IsInjective(f) and IsInjective(g) ) and ( Range(f) = Range(g) ) and ( g*pi = ZeroMapping(Source(g),Range(pi)) ) then 
# 
#
        K := LeftActingDomain(Source(g));
        B := BasisVectors(Basis(Source(g)));
        B := List(B, x -> PreImagesRepresentative(f,ImageElm(g,x)));
#
#  Computing dimension vectors so that we can insert zero matrices of 
#  the right size. 
#
        dim_vec_sourceg := DimensionVector(Source(g));
        dim_vec_sourcef := DimensionVector(Source(f));
        map := [];
        j := 0;
        for i in [1..Length(dim_vec_sourceg)] do
#
#  If the source of  g  is zero in vertex  i, then insert a zero matrix of
#  the right size, do not use any of the lifting information.
# 
            if dim_vec_sourceg[i] = 0 then
                if  dim_vec_sourcef[i] = 0 then 
                    Add(map,NullMat(1,1,K));
                else
                    Add(map,NullMat(1,dim_vec_sourcef[i],K));
                fi;
            else
#
#  If the source of  g  is non-zero in vertex  i, then use the lifting 
#  information to compute the right matrix for the map from vertex  i  to  i.
# 
                mat := [];
                for p in [1..dim_vec_sourceg[i]] do
                    j := j + 1;
                    Add(mat,ExtRepOfObj(ExtRepOfObj(B[j]))[i]);
                od;
                Add(map,mat);
            fi;
        od;
        return RightModuleHomOverAlgebra(Source(g),Source(f),map);
    else 
        return fail;
    fi;
end
);

#######################################################################
##
#O  IntersectionOfSubmodules( <f>, <g> )
##
##                                              f              g
##  Given two submodules/subrepresentations  M ---> X  and  N ---> X  of 
##  a module  X  by two monomorphism  f  and  g, this function computes 
##  the intersection of the images of  f  and  g  in the sense that it 
##  computes the pullback of the diagram
##             f'
##          E ---> N
##          |      |
##       g' |      | g 
##          |      |
##          V  f   V     
##          M ---> X
##  
##  and it returns the maps [ f', g', g'*f ]
##
InstallOtherMethod ( IntersectionOfSubmodules, 
    "for two IsPathAlgebraMatModuleHomomorphisms",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g )

    local pullback;
#
#   Checking the input
#
    if not IsInjective(f) then 
        Error("the first argument is not a monomorphism,");
    fi;
    if not IsInjective(g) then 
        Error("the second argument is not a monomorphism,");
    fi;
    if not ( Range(f) = Range(g) ) then 
        Error("must have two submodules of the same module,");
    fi;
#
#   Doing the computations
#
    pullback := PullBack(f,g);
    
    return [pullback[1],pullback[2],pullback[2]*f];
end
);

#######################################################################
##
#O  IntersectionOfSubmodules( <args> )
##
##                                            f_i             
##  Given submodules/subrepresentations  M_i -----> X  for i = 1,...,n 
##  of a module  X  by  n  monomorphism  f_i, this function computes 
##  the intersection of the images of  f  and  g  in the sense that it 
##  computes the pullbacks of the diagrams
##             f_1'
##         E_1 ----> N           E_2 ---------> N
##          |        |            |             |
##     f_2' |        | f_2   f_3' |             | f_3  and so on.
##          |        |            |             |
##          V  f_1   V            V   f_2'*f_1  V
##          M -----> X           E_1 ---------> X
##  
##  It returns the map f_n'*f_(n-1)* ... * f_2'*f_1.
##
InstallMethod ( IntersectionOfSubmodules, 
    "for two IsPathAlgebraMatModuleHomomorphisms",
    true,
    [ IsDenseList ], 
    0,
    function( list )

    local A, f, i;
#
#   Checking the input
#
    if IsEmpty( list ) then 
        Error( "<list> must be non-empty" ); 
    fi;
    A := RightActingAlgebra(Source(list[1]));
    for f in list do
        if RightActingAlgebra( Source(f) ) <> A then
            Error( "all entries in <list> must be homomorphisms of modules over the same algebra");
        fi;
    od;
    if not ForAll(list, IsInjective) then 
        Error("not all the arguments are monomorphisms,");
    fi;
    A := Range(list[1]);
    if not ForAll(list, x -> Range(x) = A) then 
        Error("must have submodules of the same module,");
    fi;
#
#   Doing the computations.
#
    f := list[1];
    for i in [2..Length(list)] do
        f := IntersectionOfSubmodules(f,list[i])[3];
    od;

    return f;
end
);

#######################################################################
##
#O  SumOfSubmodules( <f>, <g> )
##
##                                              f              g
##  Given two submodules/subrepresentations  M ---> X  and  N ---> X  of 
##  a module  X  by two monomorphism  f  and  g, this function computes 
##  the sum of the images of  f  and  g  in the sense that it computes 
##  the submodule/subrepresentation  M + N  generated by the image of  f  
##  and the image of  g. It returns the maps M + N ---> X,  M ---> M + N,  
##  N ---> M + N, in that order.  
##
InstallOtherMethod ( SumOfSubmodules, 
    "for two IsPathAlgebraMatModuleHomomorphisms",
    true,
    [ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 
    0,
    function( f, g )

    local sumMN, inclusions, projections, F;
#
#   Checking the input
#
    if not IsInjective(f) then 
        Error("the first argument is not a monomorphism,");
    fi;
    if not IsInjective(g) then 
        Error("the second argument is not a monomorphism,");
    fi;
    if not ( Range(f) = Range(g) ) then 
        Error("must have two submodules of the same module,");
    fi;
#
#   Doing the computations
#
    sumMN := DirectSumOfQPAModules([Source(f),Source(g)]);
    inclusions := DirectSumInclusions(sumMN);
    projections := DirectSumProjections(sumMN);

    F := ImageProjectionInclusion(projections[1]*f + projections[2]*g);

    return [F[2],inclusions[1]*F[1],inclusions[2]*F[1]];
end
);

#######################################################################
##
#O  SumOfSubmodules( <args> )
##
##                                            f_i             
##  Given submodules/subrepresentations  M_i -----> X  for i = 1,...,n 
##  of a module  X  by  n  monomorphism  f_i, this function computes 
##  the intersection of the images of  f  and  g  in the sense that it 
##  computes the pullbacks of the diagrams
##             f_1'
##         E_1 ----> N           E_2 ---------> N
##          |        |            |             |
##     f_2' |        | f_2   f_3' |             | f_3  and so on.
##          |        |            |             |
##          V  f_1   V            V   f_2'*f_1  V
##          M -----> X           E_1 ---------> X
##  
##  and it returns the map f_n'*f_(n-1)* ... * f_2'*f_1.
##
InstallMethod ( SumOfSubmodules, 
    "for two IsPathAlgebraMatModuleHomomorphisms",
    true,
    [ IsDenseList ], 
    0,
    function( list )

    local A, f, i;
#
#   Checking the input
#
    if IsEmpty( list ) then 
        Error( "<list> must be non-empty" ); 
    fi;
    A := RightActingAlgebra(Source(list[1]));
    for f in list do
        if RightActingAlgebra( Source(f) ) <> A then
            Error( "all entries in <list> must be homomorphisms of modules over the same algebra");
        fi;
    od;
    A := Range(list[1]);
    if not ForAll(list, x -> Range(x) = A) then 
        Error("must have submodules of the same module,");
    fi;   
    if not ForAll(list, IsInjective) then 
        Error("not all the arguments are monomorphisms,");
    fi;
#
#   Doing the computations
#
    f := list[1];
    for i in [2..Length(list)] do
        f := SumOfSubmodules(f,list[i])[1];
    od;

    return f;
end
);

#######################################################################
##
#O  HomFactoringThroughProjOverAlgebra( <M>, <N> )
##
##  Given two modules  M  and  N  over a finite dimensional quotient
##  of a path algebra, this function computes a basis of the homomorphisms
##  that factor through a projective module.
##
InstallMethod ( HomFactoringThroughProjOverAlgebra,
    "for two PathAlgebraMatModule's",
    true,
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
    0,
    function( M, N )

    local f, HomMP_N, homthroughproj, flathomthroughproj, K, V, B, dim_M,
          dim_N, homs, hom, i, j, matrices, dimension, d1, d2, matrix;
    #
    # Testing input
    #
    if RightActingAlgebra(M) <> RightActingAlgebra(N) then
        Error("the entered modules are not modules over the same algebra,");
    fi;
    #
    # if one module is zero, return the empty list
    #
    if Dimension(M) = 0 or Dimension(N) = 0 then
        return [];
    fi;
    #
    # The maps factoring through projectives are those factoring through
    # the projective cover of  N.
    #
    f := ProjectiveCover(N);
    HomMP_N := HomOverAlgebra(M,Source(f));
    homthroughproj := List(HomMP_N, x -> x*f);
    flathomthroughproj := List(homthroughproj, x -> Flat(x!.maps));
    flathomthroughproj := Filtered(flathomthroughproj, x -> x <> Zero(x));
    homthroughproj := [];
    if Length(flathomthroughproj) > 0 then
        K := LeftActingDomain(M);
        V := VectorSpace(K, flathomthroughproj);
        B := BasisVectors(Basis(V));
        dim_M := DimensionVector(M);
        dim_N := DimensionVector(N);
        homs := [];
        for hom in B do
            matrices := [];
            dimension := 0;
            for i in [1..Length(dim_M)] do
                if dim_M[i] = 0 then
                    d1 := 1;
                else
                    d1 := dim_M[i];
                fi;
                if dim_N[i] = 0 then
                    d2 := 1;
                else
                    d2 := dim_N[i];
                fi;
                matrix := [];
                for j in [1..d1] do
                    Add(matrix,hom{[dimension + 1..dimension + d2]});
                    dimension := dimension + d2;
                od;
                Add(matrices,matrix);
            od;
            Add(homs,matrices);
        od;
        homthroughproj := List(homs, x -> RightModuleHomOverAlgebra(M,N,x));
    fi;

    return homthroughproj;
end
);

#######################################################################
##
#O  EndModuloProjOverAlgebra( <M>, <N> )
##
##  Given a module  M  over a finite dimensional quotient of a path
##  algebra, this function computes the homomorphism from
##  End(M) ----> End(M)/P(M,M), where P(M,M) is the ideal in End(M)
##  generated by the morphisms factoring through projective modules.
##
InstallMethod ( EndModuloProjOverAlgebra,
    "for a PathAlgebraMatModule",
    true,
    [ IsPathAlgebraMatModule ],
    0,
    function( M )

    local EndM, factorproj, I;

    if Dimension(M) = 0 then
        Error("zero module given as input for EndModuleProjOverAlgebra,");
    else
        EndM := EndOverAlgebra(M);
        factorproj := HomFactoringThroughProjOverAlgebra(M,M);
        factorproj := List(factorproj, x -> FromHomMMToEndM(x));
        I := Ideal(EndM,factorproj);

        return NaturalHomomorphismByIdeal(EndM,I);
    fi;
end
);

#######################################################################
##
#O  FromHomMMToEndM( <f> )
##
##  This function gives a translation from endomorphisms of a module  M  
##  to the corresponding enodomorphism represented in the algebra
##  EndOverAlgebra(M). 
##
InstallMethod ( FromHomMMToEndM, 
    "for an endomorphism to an element of EndOverAlgebra",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local K, dim_vect, end_f, r, j;

    K := LeftActingDomain(Source(f));
    dim_vect := DimensionVector(Source(f));
    end_f := NullMat(Dimension(Source(f)),Dimension(Source(f)),K);
    r := 1; 
    for j in [1..Length(dim_vect)] do 
        if dim_vect[j] <> 0 then 
            end_f{[r..r+dim_vect[j]-1]}{[r..r+dim_vect[j]-1]} := f!.maps[j];
            r := r + dim_vect[j];
        fi;
    od; 

    return end_f;
end
);

#######################################################################
##
#O  FromEndMToHomMM( <M>, <mat> )
##
##  This function gives a translation from an element in 
##  EndOverAlgebra(<M>) to an endomorphism of the module  M. 
##
InstallMethod ( FromEndMToHomMM, 
    "for a subset of EndOverAlgebra to HomOverAlgebra",
    true,
    [ IsPathAlgebraMatModule, IsMatrix ],
    0,
    function( M, mat )

    local K, dim_vect, maps, i, r;

    K := LeftActingDomain(M); 
    dim_vect := DimensionVector(M);

    maps := [];
    r := 1;
    for i in [1..Length(dim_vect)] do
        if dim_vect[i] = 0 then 
            Add(maps,NullMat(1,1,K));
        else
            Add(maps,mat{[r..r+dim_vect[i]-1]}{[r..r+dim_vect[i]-1]});
            r := r + dim_vect[i];
        fi;
    od;

    return RightModuleHomOverAlgebra(M,M,maps);
end
);

#######################################################################
##
#P  IsRightMinimal( <f> )
##
##  This function returns true is the homomorphism  <f>  is right 
##  minimal. 
##
InstallMethod ( IsRightMinimal, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local B, C, BB, mat, Ann_f, radEndB;

    B := Source(f);
    C := Range(f);
    BB := HomOverAlgebra(B,B);
    mat := List(BB, x -> x*f);
    mat := List(mat,x -> Flat(x!.maps));
    Ann_f := NullspaceMat(mat);
    Ann_f := List(Ann_f,x -> LinearCombination(BB,x));
    radEndB := RadicalOfAlgebra(EndOverAlgebra(B)); 
    Ann_f := List(Ann_f, x -> FromHomMMToEndM(x));

    if ForAll(Ann_f, x -> x in radEndB) then 
        return true;
    else
        return false;
    fi;
end
);

#######################################################################
##
#P  IsLeftMinimal( <f> )
##
##  This function returns true is the homomorphism  <f>  is left 
##  minimal. 
##
InstallMethod ( IsLeftMinimal, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local A, B, BB, mat, Ann_f, radEndB;

    A := Source(f);
    B := Range(f);
    BB := HomOverAlgebra(B,B);
    mat := List(BB, x -> f*x );
    mat := List(mat,x -> Flat(x!.maps));
    Ann_f := NullspaceMat(mat);
    Ann_f := List(Ann_f,x -> LinearCombination(BB,x));
    radEndB := RadicalOfAlgebra(EndOverAlgebra(B)); 
    Ann_f := List(Ann_f, x -> FromHomMMToEndM(x));

    if ForAll(Ann_f, x -> x in radEndB) then 
        return true;
    else
        return false;
    fi;
end
);

#######################################################################
##
#A  RightInverseOfHomomorphism( <f> )
##
##  This function returns false if the homomorphism  <f>  is not a  
##  splittable monomorphism, otherwise it returns a splitting of the
##  split monomorphism  <f>. 
##
InstallMethod ( RightInverseOfHomomorphism, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local B, C, CB, id_B, mat, flat_id_B, split_f;

    B := Source(f);
    C := Range(f);
    if IsInjective(f) then 
        CB := HomOverAlgebra(C,B);
        if Length(CB) = 0 then 
            return false;
        else 
            mat := [];
            mat := List(CB, x -> f*x);
            id_B := IdentityMapping(B); 
            mat := List(mat,x -> Flat(x!.maps));
            flat_id_B := Flat(id_B!.maps); 
            split_f := SolutionMat(mat,flat_id_B);
            
            if split_f <> fail then 
                split_f := LinearCombination(CB,split_f);
                SetIsSplitEpimorphism(split_f,true);
                SetIsSplitMonomorphism(f,true);
                SetLeftInverseOfHomomorphism(split_f,f); 
                return split_f;
            else
                SetIsSplitMonomorphism(f,false);
                return false;
            fi;
        fi;
    else
        return false;
    fi;
end
  );

#######################################################################
##
#A  LeftInverseOfHomomorphism( <f> )
##
##  This function returns false if the homomorphism  <f>  is not a  
##  splittable epimorphism, otherwise it returns a splitting of the
##  split epimorphism  <f>. 
##
InstallMethod ( LeftInverseOfHomomorphism, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local B, C, CB, id_C, mat, flat_id_C, split_f;

    B := Source(f);
    C := Range(f);
    if IsSurjective(f) then 
        CB := HomOverAlgebra(C,B);
        if Length(CB) = 0 then 
            return false;
        else 
            mat := List(CB, x -> x*f );
            id_C := IdentityMapping(C); 
            mat := List(mat,x -> Flat(x!.maps));
            flat_id_C := Flat(id_C!.maps); 
            split_f := SolutionMat(mat,flat_id_C);
            
            if split_f <> fail then 
                split_f := LinearCombination(CB,split_f);
                SetIsSplitMonomorphism(split_f,true);
                SetIsSplitEpimorphism(f,true);
                SetRightInverseOfHomomorphism(split_f,f); 
                return split_f;
            else
                SetIsSplitEpimorphism(f,false);
                return false;
            fi;
        fi;
    else
        return false;
    fi;
end
  );

#######################################################################
##
#P  IsSplitMonomorphism( <f> )
##
##  This function returns false if the homomorphism  <f>  is not a  
##  splittable monomorphism, otherwise it returns a splitting of the
##  homomorphism  <f>. 
##
InstallMethod ( IsSplitMonomorphism, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local B, C, CB, id_B, mat, flat_id_B, split_f;

    B := Source(f);
    C := Range(f);
    if IsInjective(f) then 
        CB := HomOverAlgebra(C,B);
        if Length(CB) = 0 then 
            return false;
        else 
            mat := [];
            mat := List(CB, x -> f*x);
            id_B := IdentityMapping(B); 
            mat := List(mat,x -> Flat(x!.maps));
            flat_id_B := Flat(id_B!.maps); 
            split_f := SolutionMat(mat,flat_id_B);
            
            if split_f <> fail then 
                split_f := LinearCombination(CB,split_f);
                SetLeftInverseOfHomomorphism(split_f,f);
                SetRightInverseOfHomomorphism(f,split_f);
                SetIsSplitEpimorphism(split_f,true);
                return true;
            else
                return false;
            fi;
        fi;
    else
        return false;
    fi;
end
  );

#######################################################################
##
#P  IsSplitEpimorphism( <f> )
##
##  This function returns false if the homomorphism  <f>  is not a  
##  splittable epimorphism, otherwise it returns true. 
##
InstallMethod ( IsSplitEpimorphism, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local B, C, CB, id_C, mat, flat_id_C, split_f;

    B := Source(f);
    C := Range(f);
    if IsSurjective(f) then 
        CB := HomOverAlgebra(C,B);
        if Length(CB) = 0 then 
            return false;
        else 
            mat := List(CB, x -> x*f );
            id_C := IdentityMapping(C); 
            mat := List(mat,x -> Flat(x!.maps));
            flat_id_C := Flat(id_C!.maps); 
            split_f := SolutionMat(mat,flat_id_C);
            
            if split_f <> fail then 
                split_f := LinearCombination(CB,split_f);
                SetLeftInverseOfHomomorphism(f, split_f);
                SetRightInverseOfHomomorphism(split_f,f);
                SetIsSplitMonomorphism(split_f,true);
                return true;
            else
                return false;
            fi;
        fi;
    else
        return false;
    fi;
end
);

InstallMethod ( MoreRightMinimalVersion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f ) 

    local B, g, A, HomBA, HomAA, n, i, j, gg, hh;

    B := Source(f);
    g := KernelInclusion(f);
    A := Source(g);
    HomBA := HomOverAlgebra(B,A);
    if Length(HomBA) = 0 then 
        return f;
    else 
        HomAA  := HomOverAlgebra(A,A);
        n := Maximum(Concatenation(DimensionVector(A),DimensionVector(B)));
        for i in [1..Length(HomBA)] do 
            for j in [1..Length(HomAA)] do
                gg := (g*HomBA[i]*HomAA[j])^n;
                if gg <> ZeroMapping(A,A) then
                    hh := (HomBA[i]*HomAA[j]*g)^n;
                    return [KernelInclusion(hh)*f,ImageInclusion(hh)*f];
                fi;
            od;
        od;
        return f;
    fi;
end
);

InstallMethod ( MoreLeftMinimalVersion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f ) 

    local B, g, C, HomCB, HomCC, n, i, j, gg, hh, t;

    B := Range(f);
    g := CoKernelProjection(f);
    C := Range(g);
    HomCB := HomOverAlgebra(C,B);
    if Length(HomCB) = 0 then 
        return f;
    else 
        HomCC := HomOverAlgebra(C,C);
        n := Maximum(Concatenation(DimensionVector(B),DimensionVector(C)));
        for i in [1..Length(HomCC)] do 
            for j in [1..Length(HomCB)] do
                gg := (HomCC[i]*HomCB[j]*g)^n;
                if gg <> ZeroMapping(C,C) then
                    hh := (g*HomCC[i]*HomCB[j])^n;
#                    t := IsSplitMonomorphism(KernelInclusion(hh));
                    t := RightInverseOfHomomorphism(KernelInclusion(hh));
                    return [f*t,f*ImageProjection(hh)];
                fi;
            od;
        od;
        return f;
    fi;
end
);

#######################################################################
##
#A  RightMinimalVersion( <f> )
##
##  This function returns a right minimal version  f'  of the 
##  homomorphism  <f>  in addition to a list of modules  B such that 
##  Source(f') direct sum the modules on the list  B  is isomorphic to
##  Source(f).
##
InstallMethod ( RightMinimalVersion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local Bprime, g, L;

    Bprime := [];
    g := f;
    repeat
        L := MoreRightMinimalVersion(g);
        if L <> g then 
            g := L[1];
            Add(Bprime,Source(L[2]));
        fi;
    until 
        L = g;
    
    SetIsRightMinimal(g,true);

    return [g,Bprime];
end
);

#######################################################################
##
#A  LeftMinimalVersion( <f> )
##
##  This function returns a left minimal version  f'  of the 
##  homomorphism  <f>  in addition to a list of modules  B such that 
##  Range(f') direct sum the modules on the list  B  is isomorphic to
##  Range(f).
##
InstallMethod ( LeftMinimalVersion, 
    "for a PathAlgebraMatModuleMap",
    true,
    [ IsPathAlgebraMatModuleHomomorphism ],
    0,
    function( f )

    local Bprime, g, L;

    Bprime := [];
    g := f;
    repeat
        L := MoreLeftMinimalVersion(g);
        if L <> g then 
            g := L[1];
            Add(Bprime,Range(L[2]));
        fi;
    until 
        L = g;

    SetIsLeftMinimal(g,true);

    return [g,Bprime];
end
);

#######################################################################
##
#O  HomFromProjective(<m>,<M>)
##
##  This function checks if the element  <m>  is an element of  <M>  and
##  if the element  <m>  is uniform. If so, the function constructs the 
##  map from the indecomposable projective generated by the vertex of 
##  support to the module  <M>  given by sending the vertex to the 
##  element  <m>. 
##
InstallMethod ( HomFromProjective, 
    "for an element in a PathAlgebraMatModule and the PathAlgebraMatModule",
    IsElmsColls,
    [ IsRightAlgebraModuleElement, IsPathAlgebraMatModule ],
    0,
    function( m, M )

    local A, K, num_vert, support, pos, P, B, mats, zeros, i, f;
#
# Finding the algebra acting on M and the number of vertices.
#
    A := RightActingAlgebra(M);
    K := LeftActingDomain(M);
    num_vert := Length(m![1]![1]);
#   
# Finding the support of m.
#
    support := SupportModuleElement(m);
#
# If the element  m  is uniform, we proceed to find the map.
# 
    if Length(support) = 1 then 
#
# And we need the "number of" the vertex ...
#
        pos := VertexPosition(support[1]);
#
# And the basis for the correct projective module, and the proj. module itself
#
        B := BasisOfProjectives(A)[pos];
        P := ShallowCopy(IndecProjectiveModules(A)[pos]);
#
# Then we calculate the matrices for the homomorphism
#
        mats := List([1..num_vert],x -> List(B[x], y -> ExtRepOfObj(m^y)![1][x]));
        zeros := Filtered([1..num_vert], x -> DimensionVector(P)[x] = 0);
        for i in zeros do 
            if DimensionVector(M)[i] <> 0 then         
                mats[i] := NullMat(1,DimensionVector(M)[i],K);
            else 
                mats[i] := NullMat(1,1,K);
            fi;
        od;
#
# Construct the homomorphism
#
        f := RightModuleHomOverAlgebra(P,M,mats);
        return f;
    else
        return fail;
    fi;
end
);

######################################################
##
#O InverseOfIsomorphism( <f> )
##
## <f> is a map which is iso. 
##
## Output is the map f^(-1), or the inverse of f.
##
InstallMethod( InverseOfIsomorphism,
               [ IsPathAlgebraMatModuleHomomorphism ],
               function( f )
    local maps, invmaps, m;
    if not(IsIsomorphism(f)) then
        Error("entered map is not an isomorphism");
    fi;
    maps := f!.maps;
    invmaps := [];
    for m in maps do
        if IsZero(m) then
            Append(invmaps, [m]);
        else
            Append(invmaps, [Inverse(m)]);
        fi;
    od;

    return RightModuleHomOverAlgebra(Range(f), Source(f), invmaps);

end);

#######################################################################
##
#O  HomomorphismFromImages( <M>, <N>, <genImages> )
##
##  <M> and <N> are modules over the same algebra.  This operation
##  computes a homomorphism f: M ---> N such that the basis
##
##    B := BasisVectors( Basis( M ) );
##
##  is sent to the list <genImages>, that is, B[i] is sent to genImages[i].
##  If this does not give a well-defined homomorphism, the final 
##  call to RightModuleHomOverAlgebra will fail.
##
InstallMethod( HomomorphismFromImages,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule, IsList ],
    function( M, N, genImages )

    local B, K, dim_vec_N, dim_vec_M, map, i, j, mat, p; 

    K := LeftActingDomain(M);

    B := BasisVectors( Basis( M ) );

#
#  Checks that the element B[i] is sent to an element of N with support in 
#  the same vertex as B[i].
#
    for i in [1..Length(B)] do
        if ( SupportModuleElement( B[i] ) <> SupportModuleElement( genImages[i] ) ) and
           ( not IsZero( genImages[i] ) ) then
            Error("does not give a homomorphism -- wrong support,");
        fi;
    od;
    
#
#  Computing dimension vectors so that we can insert zero matrices of 
#  the right size. 
#
    dim_vec_M := DimensionVector(M);
    dim_vec_N := DimensionVector(N);
    map := [];
    j := 0;
    for i in [1..Length(dim_vec_M)] do
#
#  If M is zero in vertex  i, then insert a zero matrix of
#  the right size, do not use any of the lifting information.
# 
        if dim_vec_M[i] = 0 then
            if  dim_vec_N[i] = 0 then 
                Add(map,NullMat(1,1,K));
            else
                Add(map,NullMat(1,dim_vec_N[i],K));
            fi;
        else
#
#  If M is non-zero in vertex  i, then use genImages
#  to compute the right matrix for the map from vertex  i  to  i.
# 
            mat := [];
            for p in [1..dim_vec_M[i]] do
                j := j + 1;
                if not ( IsPathModuleElem(genImages[j]) ) then
                    if IsList( ExtRepOfObj( genImages[j] ) ) then
                        Add(mat, ExtRepOfObj( genImages[j] )[i]);
                    else
                        Add(mat, ExtRepOfObj(ExtRepOfObj(genImages[j]))[i]);
                    fi;
                else
                    Add(mat,ExtRepOfObj(ExtRepOfObj(genImages[j]))[i]);
                fi;
            od;
            Add(map,mat);
        fi;
    od;
    return RightModuleHomOverAlgebra(M, N, map);

end
);

######################################################
##
#O MultiplyListsOfMaps( <projections>, <matrix>, <inclusions> )
##
## <projections> is a list of m maps, <matrix> is a list of
## m lists of n maps, <inclusions> is a list of n maps. 
## Considering <projections> as a 1xm-matrix, <matrix> as an
## mxn-matrix and and <inclusions> as an nx1-matrix, the 
## matrix product is computed. Naturally, the maps in the 
## matrices must be composable.
##
## Output is a map (not a 1x1-matrix).
##
## Utility method not supposed to be here, but there seemed
## to be no existing GAP method for this.
##
InstallMethod( MultiplyListsOfMaps,
                    [ IsList, IsList, IsList ],
                    function( projections, matrix, inclusions )
    local sum, list, n, m, i, j;

    n := Length(projections);
    m := Length(inclusions);
    list := [1..m];
    sum := 0;

    for i in [1..m] do
       list[i] := projections*matrix[i];
    od;

    sum := list*inclusions;
    return sum;
end);

#######################################################################
##
#O  IsomorphismOfModules( <M>, <N> )
##
##  Given two modules  <M>  and  <N>  over a (quotient of a) path algebra
##  this function return an isomorphism from  <M>  to  <N>  is the two
##  modules are isomorphic, and false otherwise.
##
InstallMethod ( IsomorphismOfModules, 
    "for two PathAlgebraMatModules",
    true,
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 
    0,
    function( M, N )

    local K, dim_M, mats, i, maps, splittingmaps, fn, fsplit, gn, gsplit, 
          f_alpha, f_beta, g_alpha, g_beta, q, B, genImages, delta, 
          recursiveIOM;
    # 
    # If  M  and  N are not modules over the same algebra, 
    # return an error message.
    #
    if RightActingAlgebra(M) <> RightActingAlgebra(N) then 
        return false;
    fi;
    #
    # If the dimension vectors of  M  and  N  are different, they
    # are not isomorphic, so return  false.
    #
    if DimensionVector(M) <> DimensionVector(N) then
        return false;
    fi;
    #
    # If both  M  and  N  are the zero module, return the zero map.
    #
    if Dimension(M) = 0 and Dimension(N) = 0 then
        return ZeroMapping(M,N);
    fi;
    #
    # If  M  and  N  are the same representations (i.e. with the 
    # same vector spaces and defining matrices, then return the 
    # "identity homomorphism". 
    #
    if M = N then 
        K := LeftActingDomain(M);
        dim_M := DimensionVector(M);
        mats := [];
        for i in [1..Length(dim_M)] do
            if dim_M[i] = 0 then
                Add(mats,NullMat(1,1,K));
            else
                Add(mats,IdentityMat(dim_M[i],K));
            fi;
        od;
        
        return RightModuleHomOverAlgebra(M,N,mats);
    fi;
    #
    # Finds a homomorphism from  M  to  N  and corresponding homomorphism
    # from  N  to  M  identifying a common non-zero direct summand of  M  
    # and  N, if such exists. Otherwise it returns false. 
    #
    splittingmaps := function( M, N) 
        local K, HomMN, HomNM, mn, nm, n, m, i, j,  
              l, zero, f, fnm, nmf; 
            
        HomMN := HomOverAlgebra(M,N);
        HomNM := HomOverAlgebra(N,M);
        mn := Length(HomMN);
        nm := Length(HomNM);
      
        if mn = 0 or nm = 0 then 
            return false;
        fi;
      
        m := Maximum(DimensionVector(M));
        n := Maximum(DimensionVector(N));
        if n = m then
            l := n;
        else
            l := Minimum([n,m]) + 1;
        fi;
      
        zero := ZeroMapping(M,M);
      
        for j in [1..nm] do
            for i in [1..mn] do
                if l>1 then  # because hom^0*hom => error!       
                    f := (HomMN[i]*HomNM[j])^(l-1)*HomMN[i];
                else 
                    f := HomMN[i];
                fi;
                
                fnm := f*HomNM[j];
              
                if fnm <> zero then
                    nmf := HomNM[j]*f; 
                    return [fnm, nmf, HomMN[i]];
                fi;
            od;
        od;

        return false;
    end; 
    
    maps := splittingmaps(M,N);
    #
    # No common non-zero direct summand,  M  and  N  are not isomorphic,
    # return false.
    #
    if maps = false then
        return false;
    fi;
    #
    # M  and  N  has a common non-zero direct summand, find the splitting of
    # the inclusion of this common direct summand in  M  and in  N.
    #
    fn := ImageInclusion(maps[1]);
#    fsplit := IsSplitMonomorphism(fn);
    fsplit := RightInverseOfHomomorphism(fn);
    gn := ImageInclusion(maps[2]);
#    gsplit := IsSplitMonomorphism(gn);
#     gsplit := LeftInverseOfHomomorphism(gn);    
    gsplit := RightInverseOfHomomorphism(gn);    
    #
    # Find the idempotents corresponding to these direct summands.
    #
    f_alpha := ImageInclusion(fsplit*fn);
    f_beta := KernelInclusion(fsplit*fn);    
    g_alpha := ImageInclusion(gsplit*gn);
    g_beta := KernelInclusion(gsplit*gn);
    #
    # If this direct summand is all of  M  and  N, return the appropriate
    # isomorphism.
    #
    if Dimension(Source(f_beta)) = 0 and Dimension(Source(g_beta)) = 0 then
       return maps[1]*maps[3]; 
    fi;
    #
    # If this direct summand is not all of  M  and  N, recursively construct
    # a possible isomorphism between the complements of this common direct 
    # summand in  M  and in  N.
    #
    q := f_alpha*maps[1]*maps[3];
    
    B := BasisVectors(Basis(Source(q)));
    genImages := List(B, x -> PreImagesRepresentative(g_alpha, ImageElm(q,x)));
    
    delta := HomomorphismFromImages(Source(f_alpha), Source(g_alpha), genImages);
    
    recursiveIOM := IsomorphismOfModules(Source(f_beta),Source(g_beta));
    
    if recursiveIOM <> false then
#        return IsSplitMonomorphism(f_alpha) * (delta * g_alpha) + 
#               IsSplitMonomorphism(f_beta) * (recursiveIOM * g_beta);
        return RightInverseOfHomomorphism(f_alpha) * (delta * g_alpha) + 
               RightInverseOfHomomorphism(f_beta) * (recursiveIOM * g_beta);        
    else 
        return false;
    fi;
end
  ); # IsomorphismOfModules

#######################################################################
##
#O  EndOfModuleAsQuiverAlgebra( <M> )
##
##  The argument of this function is a PathAlgebraMatModule  <M>  over
##  a quiver algebra over a field  K. It checks if the endomorphism ring
##  of  <M>  is  K-elementary for some (finite) field K. If the endomorphism
##  ring of  <M>  is K-elementary, then it returns a list of three elements, 
##  (i)   the endomorphism ring of  <M>, 
##  (ii)  the adjacency matrix of the quiver of the endomorphism ring and 
##  (iii) the endomorphism ring as a quiver algebra.
## 
InstallMethod( EndOfModuleAsQuiverAlgebra, 
    "for a representations of a quiver",
    [ IsPathAlgebraMatModule ], 0,
    function( M )

  local EndM, EndMAsQuiverAlg;

    EndM := EndOverAlgebra( M );
    EndMAsQuiverAlg := AlgebraAsQuiverAlgebra( EndM );
    
    if EndMAsQuiverAlg <> fail then 
      return [ EndM, AdjacencyMatrixOfQuiver( QuiverOfPathAlgebra( EndMAsQuiverAlg[ 1 ] ) ), EndMAsQuiverAlg[ 1 ] ];
    else
      return fail;
    fi;
end
  );

#######################################################################
##
#O  TraceOfModule( <M>, <N> )
##
##  This function computes trace of the module  <M>  in  <N> by doing 
##  the following: computes a basis for Hom_A(M,N) and then computes 
##  the sum of all the images of the elements in this basis. This is 
##  also a minimal right Fac(M)-approximation. 
##
InstallMethod( TraceOfModule,
    "for two PathAlgebraMatModules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
    
    function( M, N )
    local homMN, B, trace;
    #
    # Checking if the modules  <M>  and  <N>  are modules over the same algebra.
    #
    if RightActingAlgebra(M) <> RightActingAlgebra(N) then
        Error("the entered modules are not modules over the same algebra,\n");
    fi;
    #
    # If  <M>  or  <N>  are zero, then the trace is the zero module.
    #
    if M = ZeroModule(RightActingAlgebra(M)) or N = ZeroModule(RightActingAlgebra(N)) then
        return ZeroMapping(ZeroModule(RightActingAlgebra(N)),N);
    fi;
    #
    # Finding a basis for  Hom(M,N), and taking the sum of all the images of these
    # homomorphisms from  <M>  to  <N>.  This is the trace of  <M>  in  <N>. 
    #
    homMN := HomOverAlgebra(M,N);
    if Length(homMN) = 0 then
        return ZeroMapping(ZeroModule(RightActingAlgebra(N)),N);
    fi;
    B := BasisVectors(Basis(M));
    trace := Flat(List(B, b -> List(homMN, f -> ImageElm(f,b))));
    
    return SubRepresentationInclusion(N,trace);
end
  );

#######################################################################
##
#O  RejectOfModule( <N>, <M> )
##
##  This function computes the reject of the module  <M>  in  <N> by doing 
##  the following: computes a basis for Hom_A(N,M) and then computes 
##  the intersections of all the kernels of the elements in this basis. 
##
InstallMethod( RejectOfModule,
    "for two PathAlgebraMatModules",
    [ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
    
    function( N, M )

    local  homNM;
    #
    # Checking if the modules  <M>  and  <N>  are modules over the same algebra.
    #
    if RightActingAlgebra(M) <> RightActingAlgebra(N) then
        Error("the entered modules are not modules over the same algebra,\n");
    fi;
    #
    # If  Hom( N, M )  is zero, then the reject is the identity homomorphism N ---> N.
    #
    homNM := HomOverAlgebra( N, M );
    if Length( homNM ) = 0 then 
        return IdentityMapping( N );
    fi;
    #
    # Using the basis we found for  Hom( N, M )  above, and taking the intersection of 
    # all the kernels of these homomorphisms in the basis.  This is the reject of  
    # <M>  in  <N>.
    #
    if Length( homNM ) = 1 then
       return KernelInclusion( homNM[ 1 ] );
    fi;
    if Length( homNM ) > 1 then
 return IntersectionOfSubmodules( List( homNM, f -> KernelInclusion( f ) ) );
    fi;
end
  );

#######################################################################
##
#O  AllSimpleSubmodulesOfModule( <M> )
##
##  Returns all the different simple submodules of a module given as
##  inclusions into the module  <M>. 
##
##  Algorithm used is based on one created by Didrik Fosse.
##
InstallMethod( AllSimpleSubmodulesOfModule, 
"for a representation",
[ IsPathAlgebraMatModule ], 
function( M )
    local   field,  simples,  socleinclusion,  soc,  blocks,  b,  s,  
            simp;
    
    field := LeftActingDomain( M );
    if not IsFinite( field ) then
        Error( "The module is not a module over an algebra over a finite field.\n" );
    fi;
    if IsZero( M ) or IsSimpleQPAModule( M ) then 
        return [ IdentityMapping( M ) ];
    fi;
    #
    # Finding all simple submodules of M. 
    #
    simples := [ ];
    socleinclusion := SocleOfModuleInclusion( M );
    soc := Source( socleinclusion ); 
    blocks := BlockSplittingIdempotents( soc ); 
    blocks := List( blocks, b -> ImageInclusion( b ) );
    for b in blocks do
        for s in Subspaces( Source( b ), 1 ) do 
            simp := SubRepresentationInclusion( Source( b ), BasisVectors( Basis( s ) ) );
            Add( simples, simp * b * socleinclusion );
        od;
    od;
    
    return simples; 
end
  );

#######################################################################
##
#O  AllSubmodulesOfModule( <M> )
##
##  Returns all the different submodules of a module given as inclusions
##  into the module  <M>. 
##  
##  Algorithm used is based on one created by Didrik Fosse.
##
InstallMethod( AllSubmodulesOfModule, 
"for a representation",
        [IsPathAlgebraMatModule], 
        function(M)
    local   field,  submodules,  length,  simples,  listofsubmodules,  
            previousstep,  dim,  dimsub,  Vspaces,  newsubmodules,  U,  
            MmodU,  allsimplesinU,  s,  newsubmodule,  V;
    
    field := LeftActingDomain( M );
    if not IsFinite( field ) then
        Error( "The module is not a module over an algebra over a finite field.\n" );
    fi;
    if IsZero( M ) then 
        return [ IdentityMapping( M ) ];
    fi;
    submodules := [ SubRepresentationInclusion( M, [ ] ), IdentityMapping( M ) ];
    if IsSimpleQPAModule( M ) then
        return submodules;
    fi;
    
    length := Dimension( M );
    #
    # Finding all simple submodules of M. 
    #
    simples := AllSimpleSubmodulesOfModule( M );
    listofsubmodules := [ ];
    listofsubmodules[ 1 ] := [ SubRepresentationInclusion( M, [ ] ) ];
    Add( listofsubmodules, simples );
    previousstep := simples; 
    dim := Dimension( M );
    dimsub := 1;
    while dimsub < dim do
        dimsub := dimsub + 1;
        Vspaces := [ ];
        newsubmodules := [ ];
        for U in previousstep do
            MmodU := CoKernelProjection( U );
            allsimplesinU := AllSimpleSubmodulesOfModule( Range( MmodU ) ); 
            for s in allsimplesinU do 
                newsubmodule := PullBack( MmodU, s )[ 2 ];
                V := Subspace( UnderlyingLeftModule( M ), 
                             List( BasisVectors( Basis( Source( newsubmodule ) ) ), b -> ExtRepOfObj( ImageElm( newsubmodule, b ) ) ) );
                if Length( newsubmodules ) = 0 then
                    Add( newsubmodules, newsubmodule );
                    Add( Vspaces, V );
                else 
                    if not ( V in Vspaces ) then
                        Add( newsubmodules, newsubmodule );
                        Add( Vspaces, V ); 
                    fi;
                fi;
            od;
        od;
        Add( listofsubmodules, newsubmodules );
        previousstep := newsubmodules;
    od; 
    
    return listofsubmodules;
end
  );

#######################################################################
##
#O  RestrictionViaAlgebraHomomorphismMap( < f, h > )
##
##  Given an algebra homomorphism  f : A ---> B and a homomorphism
##  h : M ---> N of modules over B, this function returns the induced
##  homomorphism h : M ---> N  as a homomorphism of modules over  A.
##  
InstallMethod( RestrictionViaAlgebraHomomorphismMap, 
    "for a IsAlgebraHomomorphism and a IsPathAlgebraMatModuleHomomorphism",
    [ IsAlgebraHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 0,
    function( f, h )

    local   M,  N,  K,  A,  B,  vertices,  VM,  BVM,  VN,  BVN,  mats,  
            mat,  i,  resM,  resN;

    M := Source( h );
    N := Range( h );
    K := LeftActingDomain( M );
    A := Source( f );
    B := Range( f );
    if RightActingAlgebra( M ) <> B then 
        Error( "The entered homomorphism is not over the range of the algebra homomorphism.\n" );
    fi;
    vertices := One( A ) * VerticesOfQuiver( QuiverOfPathAlgebra( A ) );
    VM := List( vertices, v -> List( BasisVectors( Basis( M ) ), m -> m ^ ImageElm( f, v ) ) ); 
    VM := List( VM, W -> Filtered( W, w -> w <> Zero( w ) ) );
    BVM := List( VM, function( W ) if IsEmpty(W) then return []; else return Basis( VectorSpace( K, W ) ); fi; end );
    VN := List( vertices, v -> List( BasisVectors( Basis( N ) ), m -> m ^ ImageElm( f, v ) ) ); 
    VN := List( VN, W -> Filtered( W, w -> w <> Zero( w ) ) );
    BVN := List( VN, function( W ) if IsEmpty(W) then return []; else return Basis( VectorSpace( K, W ) ); fi; end );
    mats := [ ];
    for i in [ 1..Length( vertices ) ] do
     mat := List( BasisVectors( BVM[ i ] ), b -> Coefficients( BVN[ i ], ImageElm( h, b ) ) ); 
 Add( mats, mat );
    od; 
    resM := RestrictionViaAlgebraHomomorphism( f, M );
    resN := RestrictionViaAlgebraHomomorphism( f, N );
    
    return RightModuleHomOverAlgebra( resM, resN, mats ); 
end
  );

#######################################################################
##
#O  AllModulesOfLengthPlusOne( <M> )
##
##  Given a list of all modules of length <n> for an algebra, this
##  function constructs all modules of length <n + 1>
##  
InstallMethod( AllModulesOfLengthPlusOne, 
"for a representation",
[ IsList ], 
function( list )
    local   A,  K,  d,  simples,  firstsyzygysimples,  extensions,  S,  
            temp,  M,  ext,  modules,  t,  i,  u,  j,  s,  coeff,  h,  
            firstsyzygylist,  nonisomodules,  noniso;
    
    if Length( list ) = 0 then 
        Error( "List entered into AllModulesOfLengthPlusOne is empty.\n" );
    fi;
    A := RightActingAlgebra( list[ 1 ] );
    K := LeftActingDomain( A );
    if not IsFinite( K ) then
        Error( "The algebra is not over a finite field.\n" );
    fi;
    if not ForAll( list, m -> RightActingAlgebra( m ) = A ) then
        Error( "List entered into AllModulesOfLengthPlusOne doesn't consist of modules over the same algebra.\n" );
    fi;    
    d := Dimension( list[ 1 ] );
    if not ForAll( list, m -> Dimension( m ) = d ) then
        Error( "List entered into AllModulesOfLengthPlusOne doesn't have the same length.\n" );
    fi;
    
    simples := SimpleModules( A );
    firstsyzygysimples := List( simples, s -> KernelInclusion( ProjectiveCover( s ) ) );
    
    extensions := [ ];
    for S in simples do
        temp := [ ];
        for M in list do
            ext := ExtOverAlgebra( S, M );
            Add( temp, ext[ 2 ] );
        od;
        Add( extensions, temp );
    od;
    
    modules := [ ];
    t := Length( extensions );  # number of simples
    for i in [ 1..t ] do
        u := Length( extensions[ i ] ); # number of elements in <list>
        for j in [ 1..u ] do
            s := Length( extensions[ i, j ] ); # dimension of Ext-space
            if s = 1 then
                Add( modules, DirectSumOfQPAModules( [ list[ u ], simples[ i ] ] ) );
                Add( modules, Range( PushOut( extensions[ i, j ][ 1 ], firstsyzygysimples[ i ] )[ 2 ] ) );
            elif s > 1 then
                for coeff in K^s do
                    h := LinearCombination( extensions[ i, j ], coeff );
                    Add( modules, Range( PushOut( h, firstsyzygysimples[ i ] )[ 2 ] ) );
                od;
            fi;
        od;
    od;
    modules := Unique( modules );

    firstsyzygylist := List( list, m -> KernelInclusion( ProjectiveCover( m ) ) );
    
    extensions := [ ];
    for M in list do
        temp := [ ];
        for S in simples do
            ext := ExtOverAlgebra( M, S );
            Add( temp, ext[ 2 ] );
        od;
        Add( extensions, temp );
    od;

    t := Length( extensions );  # number of elements in <list>
    for i in [ 1..t ] do
        u := Length( extensions[ i ] ); # number of simples
        for j in [ 1..u ] do
            s := Length( extensions[ i, j ] ); # dimension of Ext-space
            if s = 1 then
                Add( modules, DirectSumOfQPAModules( [ list[ i ], simples[ j ] ] ) );
                Add( modules, Range( PushOut( extensions[ i, j ][ 1 ], firstsyzygylist[ i ] )[ 2 ] ) );
            elif s > 1 then
                for coeff in K^s do
                    h := LinearCombination( extensions[ i, j ], coeff );
                    Add( modules, Range( PushOut( h, firstsyzygylist[ i ] )[ 2 ] ) );
                od;
            fi;
        od;
    od;
    modules := Unique( modules );

    s := Length( modules ); 
    nonisomodules := [ ];
    Add( nonisomodules, modules[ 1 ] );
    noniso := 1;
    for i in [ 2..s ] do
        if ForAll( [ 1..noniso ], j -> not IsomorphicModules( nonisomodules[ j ], modules[ i ] ) ) then
            Add( nonisomodules, modules[ i ] );
            noniso := noniso + 1;
        fi;
    od;
    
    return nonisomodules; 
end
  );

#######################################################################
##
#O  AllModulesOfLengthAtMost( <A>, n )
##
##  Returns all the different modules over an algebra of length at most
##  <n> over the algebra <A>.
## 
InstallMethod( AllModulesOfLengthAtMost, 
"for an algebra and an integer",
[ IsQuiverAlgebra, IS_INT ], 
function( A, n )
    local   field,  simples,  allmodules,  previousstep,  i;
    
    field := LeftActingDomain( A );
    if not IsFinite( field ) then
        Error( "The algebra is not over a finite field.\n" );
    fi;
    if n < 0 then
        return [ ];
    fi;
    if n = 0 then
        return [ ZeroModule( A ) ];
    fi;
    simples := SimpleModules( A );
    allmodules := Concatenation( [ ZeroModule( A ) ], simples );
    if n = 1 then 
        return allmodules;
    fi;
    
    previousstep := simples;
    for i in [ 2..n ] do
        previousstep := AllModulesOfLengthPlusOne( previousstep );
        allmodules := Concatenation( allmodules, previousstep );
    od;

    return allmodules;
end
  );

#######################################################################
##
#O  AllIndecModulesOfLengthAtMost( <A>, n )
##
##  Returns all the different indecomposable modules over an algebra 
##  of length at most <n> over the algebra <A>.
## 
InstallMethod( AllIndecModulesOfLengthAtMost, 
"for an algebra and an integer",
[ IsQuiverAlgebra, IS_INT ], 
function( A, n )
    local   allmodules;
    
    allmodules := AllModulesOfLengthAtMost( A, n );
    
    return Filtered( allmodules{ [ 2..Length( allmodules ) ] }, IsIndecomposableModule );
     
end
  );

#######################################################################
##
#A  FromIdentityToDoubleStarHomomorphism( <M> )
##
##  Returns the homomorphism from  M  to  M^{**}  for module  <M>.
##
InstallMethod( FromIdentityToDoubleStarHomomorphism, 
    "for a path algebra module",
    [ IsPathAlgebraMatModule ],
    function( M )
    
    local   A,  Aop,  K,  P,  num_vert,  V,  BV,  BasisVflat,  b,  
            Mstar,  dim_vect_star,  Pop,  Vop,  BVop,  BasisVflatop,  
            Mdstar,  dim_vect_dstar,  BM,  dimM,  matrices,  basisPop,  
            fam,  i,  temp,  start,  j,  m,  mats,  l,  mstar,  h,  
            hflat,  startpos,  endpos;
    # 
    # Setting up necessary infrastructure.
    # 
    A := RightActingAlgebra( M );
    Aop := OppositeAlgebra( A );
    K := LeftActingDomain( M ); 
    P := IndecProjectiveModules( A );
    num_vert := Length( P );
    #
    # Finding the vector spaces in each vertex in the representation of 
    # Hom_A(M,A)  and making a vector space of the flatten matrices in 
    # each basis vector in  Hom_A(M,e_iA).
    #
    V := List( P, p -> HomOverAlgebra( M, p ) );
    BV := List( V, v -> List( v, x -> 
                  Flat( MatricesOfPathAlgebraMatModuleHomomorphism( x ) ) ) );
    BasisVflat := [];
    for b in BV do
        if Length( b ) <> 0 then 
            Add( BasisVflat, 
                Basis( Subspace( FullRowSpace( K, Length( b[ 1 ] ) ), b, "basis"), b ) ); 
        else 
            Add( BasisVflat, Basis( TrivialSubspace( K^1 ) ) );
        fi;
    od;
    #
    # Computing M^*.
    #
    Mstar := StarOfModule( M );
    dim_vect_star := DimensionVector( Mstar );
    #
    # Finding the vector spaces in each vertex in the representation of 
    # Hom_Aop(M^*,Aop)  and making a vector space of the flatten matrices in 
    # each basis vector in  Hom_Aop(M^*,e^op_iAop).
    #
    Pop := IndecProjectiveModules( Aop );
    Vop := List( Pop, p -> HomOverAlgebra( Mstar, p ) );
    BVop := List( Vop, v -> List( v, x -> 
                  Flat( MatricesOfPathAlgebraMatModuleHomomorphism( x ) ) ) );
    BasisVflatop := [];
    for b in BVop do
        if Length( b ) <> 0 then 
            Add( BasisVflatop, 
                Basis( Subspace( FullRowSpace( K, Length( b[ 1 ] ) ), b, "basis"), b ) ); 
        else 
            Add( BasisVflatop, Basis( TrivialSubspace( K^1 ) ) );
        fi;
    od;
    #
    # Computing M^{**}
    #    
    Mdstar := StarOfModule( Mstar ); 
    dim_vect_dstar := DimensionVector( Mdstar );
    #
    # Computing the morphism from  M ----> M^**
    #    
    BM := BasisVectors( Basis( M ) );
    dimM := DimensionVector( M );
    matrices := [ ];
    basisPop := List( BasisOfProjectives( Aop ), b -> Flat( b ) );
    basisPop := List( basisPop, b -> Basis( Subspace( Aop, b, "basis" ) ) );
    fam := ElementsFamily( FamilyObj( A ) );
    for i in [ 1..num_vert ] do
        if dimM[ i ] = 0 then
            if dim_vect_dstar[ i ] = 0 then 
                Add( matrices, NullMat( 1, 1, K ) );
            else
                Add( matrices, NullMat( 1, dim_vect_dstar[ i ], K ) );
            fi;
        else
            if dim_vect_dstar[ i ] = 0 then
                Add( matrices, NullMat( dimM[ i ], 1, K ) );
            else
            #
            # For each m in M[ i ] construct the map from  M^* ---> A given by  g |---> g( m )
            #
                temp := [ ];
                start := Sum( dimM{ [ 1..i - 1 ] } );
                for j in [ 1..dimM[ i ] ] do
                    m := BM[ start + j ];
                    mats := [ ];
                    for l in [ 1..num_vert ] do
                        if Length( V[ l ] ) = 0 then
                            if DimensionVector( Pop[ i ] )[ l ] = 0 then
                                Add( mats, NullMat( 1, 1, K ) );
                            else
                                Add( mats, NullMat( 1, DimensionVector( Pop[ i ] )[ l ], K ) );
                            fi;
                        else
                            if DimensionVector( Pop[ i ] )[ l ] = 0 then
                                Add( mats, NullMat( Length( V[ l ] ), 1, K ) );
                            else
                                mstar := List( V[ l ], g -> ImageElm( g, m ) );
    if IsPathAlgebra( A ) then
        mstar := List( mstar, w -> ElementInIndecProjective( A, w, l ) ); 
    else
        mstar := List( mstar, w -> ElementOfQuotientOfPathAlgebra( fam, ElementInIndecProjective( A, w, l ), false ) );
    fi;
                                mstar := List( mstar, w -> OppositePathAlgebraElement( w ) );
                                mstar := List( mstar, w -> Coefficients( basisPop[ i ], w ) );
                                mstar := List( mstar, w -> LinearCombination( Basis( Pop[ i ] ), w ) );
                                mstar := List( mstar, w -> ExtRepOfObj( ExtRepOfObj( w ) )[ l ]  );
                                Add( mats, mstar );
                            fi;
                        fi;
                    od;
                    h := RightModuleHomOverAlgebra( Mstar, Pop[ i ], mats );
                    hflat := Flat( MatricesOfPathAlgebraMatModuleHomomorphism( h ) );
                    mstar := Coefficients( BasisVflatop[ i ], hflat );
                    startpos := Sum( dim_vect_dstar{ [ 1..i - 1 ] } ) + 1;
                    endpos := startpos + dim_vect_dstar[ i ] - 1;
                    mstar := LinearCombination( BasisVectors( Basis( Mdstar ) ){ [ startpos..endpos ] }, mstar );
                    mstar := ExtRepOfObj( ExtRepOfObj( mstar ) )[ i ];
                    Add( temp, mstar );
                od;
                Add( matrices, temp );
            fi;
        fi;
    od;
    
    return RightModuleHomOverAlgebra( M, Mdstar, matrices ); 
end
);

#######################################################################
##
#O  MatrixOfHomomorphismBetweenProjectives( <f> )
##
##  Given a homomorphism  <f> from <P = \oplus v_iA> to <P' = \oplus w_iA>
##  where <v_i> and <w_i> are vertices, this function finds the 
##  homomorphism as a matrix in <\oplus v_iAw_i>. 
##  
InstallMethod( MatrixOfHomomorphismBetweenProjectives, 
  "for a homomorphism between projectives",
  true,
  [ IsPathAlgebraMatModuleHomomorphism ], 0,
  function( f )
    
    local   zero,  projections,  inclusions,  A,  imageofgenerators,  
            l,  indexofprojectives;
    
    zero := Zero( OriginalPathAlgebra( RightActingAlgebra( Source( f ) ) ) );
    if IsZero( Range( f ) ) then 
        return [ [ zero ] ];
    fi;
    projections := DirectSumProjections( Range( f ) );
    if IsZero( Source( f ) ) then
        return [ List( [ 1..Length( projections ) ], i -> zero ) ];
    fi;
    inclusions := DirectSumInclusions( Source( f ) );
    if not IsDirectSumOfModules( Source( f ) ) or not IsDirectSumOfModules( Range( f ) ) then
        Error( "The enter projectives are not a direct sum indecomposable projectives.\n" );
    fi;
    
    A := RightActingAlgebra( Source( f ) );
    imageofgenerators := List( inclusions, x -> ImageElm( x,  MinimalGeneratingSetOfModule( Source( x ) )[ 1 ] ) );
    imageofgenerators := List( imageofgenerators, x -> ImageElm( f, x ) );
    l := Length( projections );
    imageofgenerators := List( imageofgenerators, x -> List( projections, p -> ImageElm( p, x ) ) );
    indexofprojectives := List( projections, x -> SupportModuleElement( MinimalGeneratingSetOfModule( Range( x ) )[ 1 ] )[ 
1 ] );
    indexofprojectives := List( indexofprojectives, x -> VertexPosition( x ) ); 
    imageofgenerators := List( imageofgenerators, x -> List( [ 1..l ], 
                                 y -> ElementInIndecProjective( A, x[ y ], indexofprojectives[ y ] ) ) ); 
    
    return TransposedMat( imageofgenerators );
end
  );

InstallMethod( FromMatrixToHomomorphismOfProjectives, 
    "for a matrix of elements in a quotient of a path algebra, and two list of vertices",
    true,
    [ IsQuiverAlgebra, IsMatrix, IsHomogeneousList, IsHomogeneousList ],
    0,
    function( A, mat, vert1, vert0 )               

  local m, P0vert, supprows, rowcount, row, tempsupp, r, test, P1vert, 
        suppcolumns, P1, P1projections, P0, P0inclusions, newmat, P, 
        dimmat, i, temp, j, fam, vfam, elem;
    
    for m in mat do
      if not ForAll( m, a -> a in A ) then
        Error( "The entered matrix is not a homogeneous matrix in one and the same algebra.\n" );
      fi;
    od;
    
    P0vert := [ ];
    supprows := List( mat, row -> List( row, r -> LeftSupportOfQuiverAlgebraElement( A, r ) ) );
    rowcount := 0;
    for row in supprows do
      rowcount := rowcount + 1;
      tempsupp := [];
      for r in row do
        if r <> [] then
          if Length( r ) > 1 then
            Error( "The entered matrix is not given by uniform elements.\n" );
          else
            Add( tempsupp, r[ 1 ] );
          fi;
        fi;
      od;
      if Length( tempsupp ) > 0 then 
        test := tempsupp[ 1 ];
        if not ForAll( tempsupp, t -> t = test ) then
          Error( "The entered matrix is not row homogeneous.\n" );
        fi;
      fi;
      if tempsupp = [] then 
        Add( P0vert, vert0[ rowcount ] );
      else
        Add( P0vert, test );
      fi;
    od;
    
    P1vert := [ ];
    suppcolumns := List( TransposedMat( mat ), row -> List( row, r -> RightSupportOfQuiverAlgebraElement( A, r ) ) );
    rowcount := 0;
    for row in suppcolumns do
      rowcount := rowcount + 1;
      tempsupp := [];
      for r in row do
        if r <> [] then
          if Length( r ) > 1 then
            Error( "The entered matrix is not given by uniform elements.\n" );
          else
            Add( tempsupp, r[ 1 ] );
          fi;
        fi;
      od;
      if Length( tempsupp ) > 0 and not ForAll( tempsupp, t -> t = tempsupp[ 1 ] ) then
        Error( "The entered matrix is not column homogeneous.\n" );
      fi;
      if tempsupp = [] then
        Add( P1vert, vert1[ rowcount ] );
      else
        Add( P1vert, tempsupp[ 1 ] );
      fi;
    od;

    if ( P1vert <> vert1 ) or ( P0vert <> vert0 ) then
      Error( "Discrepancy between entered list of vertices and support in the entered matrix.\n" );
    fi;
    
    P1 := DirectSumOfQPAModules( List( vert1, v -> IndecProjectiveModules( A )[ v ] ) );
    P1projections := DirectSumProjections( P1 );
    P0 := DirectSumOfQPAModules( List( vert0, v -> IndecProjectiveModules( A )[ v ] ) );
    P0inclusions := DirectSumInclusions( P0 );
    
    newmat := [];
    P := IndecProjectiveModules( A );
    dimmat := DimensionsMat( mat );
    for i in [ 1..dimmat[ 1 ] ] do
      temp := [];
      for j in [ 1..dimmat[ 2 ] ] do
        r := mat[ i ][ j ];
        if IsZero( r ) then
          Add( temp, ZeroMapping( Range( P1projections[ j ] ), Source( P0inclusions[ i ] ) ) );
        else
          fam := FamilyObj( Zero( Source( P0inclusions[ i ] ) )![ 1 ] );
          vfam := FamilyObj( Zero( Source( P0inclusions[ i ] ) ) );
          elem := ElementIn_vA_AsElementInIndecProj( A, r );
          elem := ExtRepOfObj( ExtRepOfObj( elem ) );
          elem := ObjByExtRep(vfam, PathModuleElem( fam, elem ) );
          Add( temp, HomFromProjective( elem, Source( P0inclusions[ i ] ) ) );
        fi;
      od;
      Add( newmat, temp );
    od;
    
    for i in [ 1..dimmat[ 1 ] ] do
      for j in [ 1..dimmat[ 2 ] ] do
        newmat[ i ][ j ] := P1projections[ j ] * newmat[ i ][ j ] * P0inclusions[ i ];
      od;
    od;
    
    return Sum( Flat( newmat ) );
end
  );