#(C) Graham ellis 2008

#####################################################################
#####################################################################
##
##  Method for applying Hom_G(_,A) to one boundary homomorphism in
##  a free ZG-resolution R. We won't document this method in the manual
##  as it is really only for internal use.
InstallMethod(HomToGModule,
[IsHapResolution,IsInt,IsGOuterGroup,IsGOuterGroup,IsGOuterGroup],
function(R,n,A,M,N)
local phitmp,phi,UM,UN, act, MAT,i,x,b,fn,s,P,p,gns,xx,g;

#M:=DirectProductGog(List([1..R!.dimension(n)],i->A));
#N:=DirectProductGog(List([1..R!.dimension(n+1)],i->A));
UM:=ActedGroup(M);
UN:=ActedGroup(N);
act:=OuterAction(A);

MAT:=List([1..R!.dimension(n)],i->List([1..R!.dimension(n+1)],j->[]));

for i in [1..R!.dimension(n+1)] do
for x in R!.boundary(n+1,i) do
Add(MAT[AbsInt(x[1])][i],SignInt(x[1])*x[2]);
od;
od;

 ##########################################################
 fn:=function(j,a) #Here a is in A and i is the component of the product
 local x,i,ans;
 
 ans:=One(UN);
 for i in [1..R!.dimension(n+1)] do
 for x in MAT[j][i] do
 <p>< id""name=""<a</>
          act(R!.elts[AbsInt(x)],a)^SignInt(x) );
 od;
 od;
 return ans;
 end;
 ##########################################################

#phitmp:=GroupHomomorphismByFunction(UM,UN,x->
#Product(List([1..R!.dimension(n)],j->fn(j,Image(Projection(UM,j),x))))
#);
gns:=GeneratorsOfGroup(UM);
P:=[];
for g in gns do
p:=Product(List([1..R!.dimension(n)],j->fn(j,Image<5>4.-ProjectFromProductQuiver</5>
          #ADDED July 2023
if p=1 then Add(P,One(UN));
else
Add(P,p);
fi;
od;
phitmp:=GroupHomomorphismByImages(UM,UN,gns,P);

phi:=GroupHomomorphismByImagesNC(UM,UN,
GeneratorsOfGroup(UM),
List(GeneratorsOfGroup(UM),a->Image(phitmp,a)));

return GOuterGroupHomomorphism(M,N,phi);
end);
#####################################################################
#####################################################################


#####################################################################
#####################################################################
##
##  Method for applying Hom_G(_,A) to a free ZG-resolution R.
InstallMethod(omToGModule,
[IsHapResolution,IsGOuterGroup],
function(R,A)
local gogs,homos,Boundary, properties, L,T;

L:=EvaluateProperty(R,"length");
homos:=[1..L];  #homs[1] has source in degree 0.
gogs:=[1..L+1]; #gogs[1] is the chain module C_0

T:=TrivialGModuleAsGOuterGroup(R!.group,Group(Identity(A!.ActedGroup)));

########################################
Boundary:=function(n)
if IsInt(homos[n+1]) then
if IsInt(gogs[n+1]) then 
 if R!.dimension(n)>0 then
 gogs[n+1]:=
 DirectProductGog(List([1..R!.dimension(n)],i->A)); 
        else
        gogs[n+1]:=T;
        fi;
fi;
if IsInt(gogs[n+2]) then 
 if R!.dimension(n+1)>0 then
        gogs[n+2]:=
        DirectProductGog(List([1..R!.dimension(n+1)],i->A)); 
        else
        gogs[n+2]:=T;
              ;
fi;
homos[n+1]:=HomToGModule(R,n,A,gogs[n+1],gogs[n+2]);
fi;
return homos[n+1];
end;
########################################

return Objectify(HapGCocomplex,
                rec(
  resolution:=R,
  module:=A,
                boundary:=Boundary,
                properties:=
                [["length",L],
                ["type", "Gcomplex"],
                 ]));
end);



#####################################################################
#####################################################################
##
InstallMethod( ViewObj,
"for HapGComplex",
[IsHapGCocomplex],
 function(R)
Print("G-cocomplex of length ",
EvaluateProperty(R,"length"), " . \n"<p> following  showshow   relatedto    ./>
 end);

InstallMethod( PrintObj,
"for HapGComplex",
[IsHapGCocomplex],
function(R)
Print("G-cocomplex of length ",
EvaluateProperty(R,"length"), " . \n");
end);
#######################################################################
#######################################################################

#######################################################################
#######################################################################
InstallMethod(Cohomology,
    "Cohomology of a G-cocomplex returned as abelian invariants",
     [IsHapGCocomplex,IsInt],
function(C,n);

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
return 
AbelianInvariants(
Kernel(Mapping(C!.boundary(n<ivclass=example"<pre>
fi;

return
AbelianInvariants(
Kernel(Mapping(C!.boundary(n)))
/
Image(Mapping(C!.boundary(n-1)))
);
end);

#######################################################################
#######################################################################
InstallMethod(CohomologyModule,
    "Cohomology of a G-cocomplex returned as abelian invariants",
     [IsHapGCocomplex,IsInt],
function(C,)
local  H,N,A,R,alpha,nat,coh,
 ClassRepresentative,RepresentativeCocycle, 
 DP,dim,
 StandardCocycle;

if n=0 then
return Kernel(C!.boundary(0));
fi;

#####################
#####################  6 December 2016
if IsBound(C!.cohmod) then
if IsBound(C!.cohmod[n]) then
return C!.cohmod[n];
fi;
else C!.cohmod:=[];
fi;
#####################
#####################


DP<span"APprompt">ap&;/span> span class="q2 : Quiver( [ "1" v2" v3 ],span>
H:=Kernel(C!.boundary(n));
N:=Range(C!.boundary(n-1));   
nat:=NaturalHomomorphism(H,N);
coh:=Target(nat);
coh!.nat:=nat;
coh!.cocomplex:=C;

if not "resolution" in NamesOfComponents[ [ "1,"v2,""]
C!.cohmod[n]:=coh; return coh; fi;

##
##  The rest of this method is devoted to producing a cocycle 
##  for each element of coh.

A:=C!.module;
alpha:=OuterAction(A);
R:=C!.resolution;


 ###############################################
ClassRepresentative=function(c 
 local cc;    #for the class c, and return 
      #it as a list

 cc:=PreImagesRepresentative(Mapping(nat),c);
 return
 List([1..R!.dimension(n)],i->Image(Projection(DP,i),cc));
 end;
 ###############################################lt;  3 and2java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 ###############################################
 RepresentativeCocycle:=span=GAPprompt>><span><class"> :QuiverProduct ,q2 ;/java.lang.StringIndexOutOfBoundsException: Index 102 out of bounds for length 102
 local lst,cocycle,stancocycle,CocycleRec;

 lst:=ClassRepresentative(c);

   #############################################
   cocycle:=function(w) #where w is a word in R_n
   local xans;
   
   ans:=One(ActedGroup(A));
   for x in w do
   ans:=ans * alpha(R!.elts[x[2]],lst[AbsInt(x[1])])^SignInt(x[1]);
  class"">&;</span span ="q1_q2.1_*q1_q2.a_v2;/java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
  
   return ans;
   end;
   #############################################

   #############################################
   stancocycle:=function(arg);
          return cocycle(Syzygy(u1_b*_java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   end;
   #############################################

##  Let's speed things up
##  for small groups and
##  2-cocycles.

   if Order(R!.group)<2001 and n<pan class="GAPprompt>gap>/> <pan ""(  .a b*q2 ,q1_q2 )<span>
    CocycleRec:=
             List([1..Order(R!.group)], i->
                List([1..Order(R!.group)],j->0) );
   #############################################*2_bu2_c
   stancocycle:=function(arg)
   local  u,v;
          u:=Position(Elements(R!.group),arg[1]); 
          v:=Position(Elements(R!.group),arg[2]);

   if <span class="GAPpromptgapgt/>spanclass">( ,q1_q2.  .2b* .u2_c ;/>
          CocycleRec[u][v]:= cocycle(Syzygy(R,List([1..Length(arg)],i->arg[i])));
          fi;
          
   return CocycleRec[u][v];
          end;
   #############################################
   fi;

##  Finishished speeding things up.
##  
##

 return StandardNCocycle(A,stancocycle,n);
 end;
 ###############################################

coh!.representativeCocycle:=RepresentativeCocycle;
C!.cohmod[n]:=coh; return coh;
<spanclass=GAPprompt>><span><pan class=GAPinput>: ( q1_q2)<span
##################################################################

#######################################################################
#######################################################################
##
##  Method for kernel of G-outer group homomorphisms.
##
InstallMethod(Kernel,
 Kernel G-group"java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
              [IsGOuterGroupHomomorphism],
function(PHI)
<spanclass=G"gt<span spanclass=G>1_[1]<span>

K:=GOuterGroup();
SetActingGroup(K,ActingGroup(Source(PHI)));
SetActedGroup(K,Kernel(Mapping(PHI)));
SetOuterAction(K,OuterAction(Source(PHI&t; 2verticesand  gtjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
return K;
end);

#######################################################################
#######################################################################
##
##  Method for image of G-outer group homomorphisms. We'll use "Range"
##  as "Image" is a function.
InstallOtherMethod(Range,
        "Range=Image of G-outer group java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 12
              [IsGOuterGroupHomomorphism],
function(PHI)
local K;

K:=GOuterGroup();
SetActingGroup(K,ActingGroup(Source(PHI)));
SetActedGroup(K,Image(Mapping(PHI)));
SetOuterAction(K,OuterAction(Target(PHI)));
return K;
end)<< idXname"java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 62


#######################################################################
#######################################################################
##
##  Method for quotient homomorphism for G-outer groups.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
        "Quotient of G-outer groups",
              [IsGOuterGroup,IsGOuterGroup],
function(H,M)
U,UM,beta

if not ActingGroup(H)=ActingGroup(M) then 
Print("There must be a common acting group. \n");
return fail; fi;

UH:=ActedGroup(H);
UM:=ActedGroup(M);
nat:=NaturalHomomorphismByNormalSubgroup< class""<ableclass"func" =100>tr< =""< class""&an style='color:green'>8227; TensorProductOfAlgebras</code>( <var class="Arg">FQ1</var>, <var class="Arg">FQ2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
Q:=GOuterGroup();

alpha:=OuterAction(H);

 #############################################
 beta:=function(g,a);
 return
Image,(,(nat,a));
 end;
 #############################################

SetActingGroup(Q,ActingGroup(H));
SetActedGroup(Q,Image(nat));
SetOuterAction(Q,beta);
return GOuterGroupHomomorphism(H,Q,nat);
end);


#######################################################################
#######################################################################
##
##  Method for quotient \/ for G-outer groups.
InstallOtherMethod(\/,
        "Quotient of G-outer groups",
              [IsGOuterGroup,IsGOuterGroup],
function(H,M);

return Target(NaturalHomomorphism(H,M));

end);


#############################################################################
##
##  Creation empty standard2cocycle 
##
InstallMethod( StandardNCocycle,
    "method for creating a 2cocycle with no attributes set",
    [ ],

    function( )
        local N, type;
                N:= rec();
                type:= NewType(NewFamily("standard2cocycle"),
         IsStandardNCocycle and 
                       <p>The result is a quotient of a path algebrawhose is  code class="func">uiverProduct<> (< href=chap4htmlX835BBBE18104654A"><span class="RefLink">4.17-1</span></a>) of the quivers of the operands.</p>

        ObjectifyWithAttributes(N,type);
        return N;
     end);


#############################################################################
##
##  Creation standard N-cocycle
##
InstallMethod( StandardNCocycle,
    "method for creating an N-cocycle with no attributes set",
    [IsGOuterGroup,IsFunction,IsInt ],

    function(A,f,n )
        local C
 C:=StandardNCocycle();
 SetCoefficientModule(C,A);
        SetMapping(C,f);
 SetArity(C,n);

        return C;
     end);


#####################################################################
#####################################################################
##
InstallMethod( ViewObj,
"for StandardNCocycle",
[IsStandardNCocycle],
 function(R)
Print("Standard ",R!.Arity,"-cocycle \n");
 end<5>.17-7TensorAlgebrasInclusion/>

InstallMethod( PrintObj,
"for StandardNCocycle",
[IsStandardNCocycle],
 function(R)
Print("Standard ",R!.Arity,"-cocycle \n");
 end);

#######################################################################
#######################################################################

#######################################################################
#######################################################################
InstallMethod(CohomologyClass,
"Constructing a second cohomology class from a standard 2-cocycle G x G --> A",
[,IsStandardNCocycle],
function(H,f)
local cls,A,R, C, P, G, F, FhomG, K, u,v,k, L, r, x, e, i, j, gensF, nat;

#H is the seconfd cohomology
#f is a standard cocycle

C:=H!.cocomplex;
R:=C!.resolution;
P:=PresentationOfResolution(R);
F:=P.freeGroup;
gensF:=GeneratorsOfGroup(F);
G:=R!.group;
FhomGjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
A:=f!.CoefficientModule;
A:=A!.ActedGroup;
nat:=H!.nat;
K:=Source(nat);
K:=K!.ActedGroup;
K:=K!.ParentAttr;
cls:=One(K);

#We want a cocycle k:R_2 ---> A corresponding to f:G x G --> A

k:=[];
for r in  P.relators do

L:=[];
e:=ExtRepOfObj(r);
for i in [1..Length(e)/2] do
for j in [1..AbsInt(e[2*i])] do
Add(L,gensF[e[2*i-1]]^SignInt(eme="X7B31F4F680135E72"<a></p
od;
od;

Apply(L,x->Image(FhomG,x));

x:=One(A);
for i in [1..Length(L)-1] do
u:=Product(L{[1..i]});
v:=L[i+1];
x:=x*f!.Mapping(u,v);
od;
Add(k,x);
od;
for i in [1.<>4178java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 28
cls:=cls*Image(Embedding(K,i),k[i]);
od;

cls:=Image(nat!.Mapping,cls);
return cls;
end);
#######################################################################
#######################################################################