#############################################################################
##
##  normpro.gi                      CRISP                    Burkhard Höfling
##
##  Copyright © 2000, 2001, 2003, 2005 Burkhard Höfling
##


#############################################################################
##
#M  PcgsNormalizerOfPronormalSubgroup(<pcgs>, <ppcgs>)
##
##  returns the normalizer of the group generated by <ppcgs> in <pcgs>. 
##  The former must must be pronormal in the latter(in particular,
##  it must be a subgroup(which we don't check).
##
InstallMethod(PcgsNormalizerOfPronormalSubgroup, 
    "for pcgs refining an el. ab. series",
    IsIdenticalObj, 
    [IsPcgs, IsPcgs and HasParentPcgs], 0, 
    function(pcgs, ppcgs)
    
    local parentpcgs, N, r, 
        alpha, i, j, k, l, z, y, start,
        F, p, field, npcgs, pnpcgs, pmodn, pmodndepths,
        depths, ind, range, one,
        conj, e, v, w, 
        null, mat, sol, n, NN, sub, inters, gens;

    parentpcgs := ParentPcgs(pcgs);
    
    if not IsPcgsElementaryAbelianSeries(pcgs) then
        Error("pcgs must refine an elementary abelian series");
    elif parentpcgs <> ParentPcgs(ppcgs) then
        Error("pcgs and ppcgs must have the same parent pcgs");
    fi;
    ind := IndicesEANormalSteps(pcgs);
    
    N := List([1..Length(ind)], 
        i -> InducedPcgsByPcSequenceNC(parentpcgs, pcgs{[ind[i]..Length(pcgs)]}));
    r := Length(N);
        
    # since <pcgs>/N[2] is abelian, every subgroup is normal
    if r < 3 then
        return pcgs;
    fi;
    
    one := One(GroupOfPcgs(pcgs));
    ppcgs := CanonicalPcgs(ppcgs);
    depths := List(ppcgs, y -> DepthOfPcElement(pcgs, y));
    
    # <ppcgs, N[2]> is normalized by the elements in npcgs
    npcgs := List(pcgs mod N[2]);
    conj := List(npcgs, g -> List(ppcgs, y -> y^g)); 

    for i in [3..r] do
        
        Info(InfoNormalizer, 1, "starting level ",i, " of ",r,
            " with ",Length(npcgs)," generators");
        # we assume that <ppcgs, N[i-1]> is normalized by the elements in npcgs

        # compute a pcgs npcgs of N_GN[i](<ppcgs>N[i]) modulo <ppcgs>N[i] from one of
        # N_GN[i-1](<ppcgs>N[i-1]) modulo <ppcgs> N[i-1]

        # first find N[i-1] mod(<ppcgs> inters N[i-1]) N[i]

        sub := Filtered([1..Length(ppcgs)], k -> depths[k] < ind[i]);

        pmodn := ppcgs{sub};
        pmodndepths := depths{sub};
        
        pnpcgs := InducedPcgsByPcSequenceNC(parentpcgs, 
            Concatenation(pmodn, N[i]));


        inters := Filtered(sub, k -> depths[k] >= ind[i-1]);
        F := N[i-1] mod
            InducedPcgsByPcSequenceNC(parentpcgs, Concatenation(ppcgs{inters}, N[i]));

        if Length(F) > 0 then
            # get the exponent of N[i-1]/N[i]
            p := RelativeOrderOfPcElement(F, F[1]);
            field := GF(p);
                
            for j in [1..Length(npcgs)] do
                
                # multiply npcgs[j] by an
                # element in F such that it centralises the generators of
                # <ppcgs>N[i] - the required exponents of elements in F
                # can be found by solving a linear system

                if Length(pmodn) > 0 then 
                
                    # determine the conjugation action of npcgs[j]
                    # on <ppcgs>N[i]
        
                    n := List(conj[j], y -> 
                        SiftedPcElementWrtPcSequence(pcgs, pmodn, pmodndepths, y));
                                
                    Assert(1, ForAll([1..Length(ppcgs)], 
                        k -> conj[j][k] = ppcgs[k]^npcgs[j]),
                        Error("conj[j][k] <> ppcgs[k]^npcgs[j]"));
                    Assert(1, ForAll(sub, k -> SiftedPcElement(N[i-1],n[k]) = one),
                        Error("ppcgs[k]^npcgs[j] does not lie in PN[i-1]"));
                    
                    Info(InfoNormalizer, 2, "adjusting element ",npcgs[j],
                        " of depth ",DepthOfPcElement(pcgs, npcgs[j]));
    
                    mat := [];
                    sol := [];
                    
                    for l in [1..Length(F)] do
                        mat[l] := [];
                    od;
                    
                    for k in [1..Length(pmodn)] do
                        for l in [1..Length(F)] do
                            e := ExponentsConjugateLayer(F, F[l], conj[j][k])* One(field);
                            e[l] := e[l] - One(field);
                            Append(mat[l],e);
                        od;    
                        
                        Append(sol, ExponentsOfPcElement(F, n[k]) * One(field));
                    od;
                    
                    # now solve the system and adjust g
                    w := SolutionMat(mat , sol);
                    z := PcElementByExponentsNC(F, List(w, IntFFE ));
    
                    npcgs[j] := npcgs[j] * z;
                    Assert(1, 
                        ForAll(ppcgs, y -> 
                            SiftedPcElement(pnpcgs, Comm(y,npcgs[j]))
                                    = one),
                        Error("npcgs[j] does not normalize modulo N[i]"));
                    
                    Info(InfoNormalizer, 3, "adjusted element ",npcgs[j], 
                        " now of depth ", DepthOfPcElement(pcgs, npcgs[j]));
                        
                    for k in [1..Length(ppcgs)] do
                        conj[j][k] := conj[j][k]^z;
                        Assert(1, conj[j][k] = ppcgs[k]^npcgs[j],
                            Error("conj[j][k] <> ppcgs[k]^npcgs[j]"));
    
                    od;
                else
                    Info(InfoNormalizer, 3, "unchanged element ",npcgs[j], 
                        " of depth ", 
                        DepthOfPcElement(pcgs, npcgs[j]));
                    Assert(1, ForAll([1..Length(ppcgs)], k ->conj[j][k] = ppcgs[k]^npcgs[j]),
                        Error("conj[j][k] <> ppcgs[k]^npcgs[j]"));
                    Assert(1, 
                        ForAll(ppcgs, y -> 
                            SiftedPcElement(pnpcgs, Comm(y,npcgs[j]))
                                    = one),
                        Error("npcgs[j] does not normalize modulo N[i]"));
                fi;
            od;
            
            # now find centralising elements in N[i-1]/N[i-1] inters <ppcgs>N[i]
    
            if Length(pmodn) > 0 then
                mat := [];
                for l in [1..Length(F)] do
                    mat[l] := [];
                od;
                    
                for y in pmodn do
                    for l in [1..Length(F)] do
                        e := ExponentsConjugateLayer(F, F[l], y)* One(field);
                        e[l] := e[l] - One(field);
                        Append(mat[l],e);
                    od;    
                od;
        
                gens := NullspaceMat(mat);
                Assert(1, ForAll(gens, w -> 
                    ForAll(ppcgs, y -> 
                    SiftedPcElement(pnpcgs, 
                            Comm(y,PcElementByExponentsNC(F, List(w, IntFFE)))) 
                    = one)),
                Error("w does not normalize modulo N[i]"));
            
                if Length(gens) > 0 then
                    null := VectorSpace(field, gens);
                    for v in CanonicalBasis(null) do
                        z := PcElementByExponentsNC(F, List(v, IntFFE));
                        Add(npcgs, z);
                        Add(conj, List(ppcgs, y -> y^z)); 
                        Assert(1, ForAll(ppcgs, y -> 
                            SiftedPcElement(pnpcgs, Comm(y,z)) = one),
                            Error("last element of npcgs does not normalize modulo N[i]"));
                        Info(InfoNormalizer, 2, "additional centralising generator: ",
                            npcgs[Length(npcgs)], " of depth ", 
                            DepthOfPcElement(pcgs, npcgs[Length(npcgs)]));
                    od;
                fi;
            else # everything centralises 
                for z in F do
                    Add(npcgs, z);
                    Add(conj, List(ppcgs, y -> y^z)); 
                    Assert(1, ForAll(ppcgs, y -> 
                        SiftedPcElement(pnpcgs, Comm(y,z)) = one),
                        Error("last element of npcgs does not normalize modulo N[i]"));
                    Info(InfoNormalizer, 2, "additional centralising generator: ",
                        npcgs[Length(npcgs)], " of depth ", 
                        DepthOfPcElement(pcgs, npcgs[Length(npcgs)]));
                od;
            fi;
        fi;
        
        # finally, add elements from <ppcgs> N[i] inters N[i-1]
        
        for z in ppcgs{inters} do
            Add(npcgs, z);
            Add(conj, List(ppcgs, y -> y^z)); 
            Assert(1, ForAll(ppcgs, y -> 
                SiftedPcElement(pnpcgs, Comm(y,z)) = one),
                Error("last element of npcgs does not normalize modulo N[i]"));
            Info(InfoNormalizer, 3, "additional generator from <ppcgs>: ",
                npcgs[Length(npcgs)], " of depth ", 
                DepthOfPcElement(pcgs, npcgs[Length(npcgs)]));
        od;
        
        SortParallel(npcgs, conj, 
            function(x, y) 
                return DepthOfPcElement(pcgs, x) < DepthOfPcElement(pcgs, y); 
            end);
            
        Assert(1, ForAll([1..Length(npcgs)-1], 
            k -> DepthOfPcElement(pcgs, npcgs[k]) < DepthOfPcElement(pcgs, npcgs[k+1])),
            Error("npcgs is not a pcgs"));

        Assert(1, ForAll(ppcgs, y ->
            SiftedPcElement(
                InducedPcgsByPcSequence(parentpcgs, Concatenation(npcgs, N[i])), 
                y) 
            = one),
            Error("<ppcgs> is not a subgroup of its normalizer"));
        Assert(1, ForAll(npcgs, z ->
            ForAll(ppcgs, y -> 
                SiftedPcElement(pnpcgs, Comm(y                    Info(InfoNormalizer, 2, "additional centralising generator: ",
                    Error("last npcgs[Length(npcgs]," of depth" 
        (1, ForAllnpcgs z- ForAll(ppcgs,y->
            SiftedPcElement(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 19
                Error("element ofAssert, (ppcgs,y ->
    java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 58
                    
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 52
        Length(java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 52
        
            Error("element od;

    (java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 56
    
end);


# ssertForAll(1.Length()1java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
##
#M  Error("npcgsnot pcgs")
##
# theofsubin<rp><> bea 
##  subgroup of <grp>, i.e., for everySiftedPcElement
#   in join
##
java.lang.StringIndexOutOfBoundsException: Range [16, 2) out of bounds for length 19
    upcgs",
    IsIdenticalObj, 
    [IsGroup IsFinite  CanEasilyComputePcgs,IsGroup] 0,
    functionP)
        java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 59
        pcgs := PcgsElementaryAbelianSeries(H);
        return SubgroupByPcgs(H,
            PcgsNormalizerOfPronormalSubgroup        1,ForAllnpcgs,z->ForAll(pcgs,y-> 
    end)
    

#####od;
##
#M  Assert(1, ForAll(npcgs, z -> ForAll(ppcgs, y -> 
##
InstallMethodp,java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 48
    "via IsomorphismPcGroup",
    IsIdenticalObj, 
    [IsSolvableGroup and IsFinite, IsGroup], 0, 
    functionG, )
        
        if endjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            ();
        
        <, <sub>
        
                NormalizerOfPronormalSubgroup(ImagesSource(iso), ImagesSet(iso, H))#  returns the normalizer of <sub> in <grp>. <sub> must be a pronormal
    end);
        

#############################  conjugate in their join.
##
#M  NormalizerOfPronormalSubgroup(<grp>, #java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
##
InstallMethod(IsGroup and IsFinite CanEasilyComputePcgs,IsGroup],0, 
    "via nice pcgs;
    sIdenticalObj
    [IsGroup and IsHandledByNiceMonomorphism, IsGroup], 0, 
    function(G, H            PcgsNormalizerOfPronormalSubgroupp, InducedPcgs(cgsP))
        iso;
        iso := java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return PreImagesSet(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 2
                NormalizerOfPronormalSubgroup, 
    end);
        

### sIdenticalObj 
# IsSolvableGroup IsFinite], 0,
#M  function(G
##
InstallMethodjava.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 45
             = IsomorphismPcGroupG;
    IsIdenticalObj, 
    [IsGroup, IsGroup], 0, 
    function(G, NormalizerOfPronormalSubgroup(),(iso,H;
        if IsFinite)
            return java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
        else
            return Normalizer(G, H);
        fi#  NormalizerOfPronormalSubgroupgrp>,<subjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    end);    [java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 59
        

#########################################
##
#E
##