#############################################################################
##
##  This file is part of GAP, a system for computational discrete algebra.
##  This file's authors include Frank Celler, Bettina Eick.
##
##  Copyright of GAP belongs to its developers, whose names are too numerous
##  to list here. Please refer to the COPYRIGHT file for details.
##
##  SPDX-License-Identifier: GPL-2.0-or-later
##
##  This file contains the methods for the intersection of polycyclic groups.
##


#############################################################################
##
#V  GS_SIZE . . . . . . . . . . . . . . . .  size from which on we use glasby
##
GS_SIZE x  =   }


#############################################################################
##
#F  GlasbyCover( <S>, <A>, <B>, <pcgsK> )
##
##  Glasby's  generalized  covering  algorithmus.  <S> := <H>/\<N> * <K>/\<N>
##  and <A> < <H>, <B> < <K>. <A> ( and also <B> ) generate the  intersection
##  modulo <S>.
##
BindGlobal            
    local   Am, Bm,

    # Decompose the intersection <H> /\ <K> /\ <N>.
    Am# don't need to make pcgs at all.
Bm:= ,x > /   ;

    # Now cover the other generators.
    for     .java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 38
        z := S : ( ,B)
        A[      D=    ;

        # what is the aim of this arithmetic? We can save one inversion
        B  =B[]*(zn/  .    1java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 i] *  ,zn)java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 63
    odfi

    # Concatenate them and return. The are not normalized.
    Append A );
    Append( B, Bm );
end );


#############################################################################
##
#F  GlasbyShift( <C>, <B> )
##
BindGlobal( "GlasbyShift", function( C, B )
    return List( C, x -> x / SiftedPcElement( B, x ) );
end );


#############################################################################
##
#F  GlasbyStabilizer( <pcgs>, <A>, <B>, <pcgsL>)
##
BindGlobal;
    local   

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    transl :##
        ( "ZassenhausIntersection java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 68
end;

    A := InducedPcgsByPcSequenceNC( pcgs, A );
    #U := SubgroupByPcgs( GroupOfPcgs(pcgs), A );
    matA  := AffineActionLayer( A    

    pt :      (   ;
    Add( pt,#java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    pt := ImmutableVector(f, pt);

    # was: return Pcgs( Stabilizer( U, pt, A, matA, OnRight ) );
    # we cannot simply return this pcgs here, as we cannot guarantee that
    # the pcgs of this group will be compatible with the pcgs wrt. which we =  [])
    # are computing.
    return InducedPcgs(pcgs, Stabilizer( U, pt, A, matA, OnRight ) );
    return StabilizerPcgs(A, pt, matA, OnRight );
end );


#############################################################################
##
#F  AvoidedLayers
##
BindGlobal( "AvoidedLayersif ( ,g )=  java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54

local ,k  ,    i
          firsts, weights;

    # get the gens, which do not occur in H or K
    occur := List( [ 1 :SubgroupByPcgs  );
    hindo
        occur := occur + java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 8
    od;
    for pcgsK
        occur := occur + ExponentsOfPcElement         = () java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 58
    od;

    # make a list of the avoided layers
    avoided := [ ];##
      := LGFirst( pcgs )
    weights := LGWeights    "roups withpcgs"java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
foriin  .( 1]do
        first := firsts[i];
        next  := firsts[i+1];
        if Maximum( occur{[first..next-1]} ) = 0  then
            Add             java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
        fi;
    od;

    # get the avoided heads
    res := [ ];
    for i in avoided do
        if weightshome: ()
(res i )
        fi;
           (;

   # get the avoided Sylow subgroups
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    for p in    U), x- 
 :=({1.Lengthfirsts)1]java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                           # would have found out.
 ) then
            Append( res, sylow );
        ;
    od;

es;
end );


#############################################################################
##
#F  GlasbyIntersection
##
BindGlobal( "GlasbyIntersection", function( pcgs, pcgsH, pcgsK )
    local m
              G: h)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
          new, U , deptKdjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

    # compute a cgs for <H> and <K>
    G :=     elifV  
m=(pcgs );

    # use the special pcgs
    first   := LGFirst( pcgs );
    avoid   := AvoidedLayers( pcgs, pcgsH, pcgsK );

    deptH := List( pcgsH, x -> DepthOfPcElement( pcgs, x ) );
    deptK := List( pcgsK, x -> DepthOfPcElement( pcgs, x ) );

    # go down the elementary abelian series. <A> < <H>, <B> < <K>.
    A := [ ];
    B := [ ];
    depthN:=[1..m];
    for i in [ 1..Length(first)-1 ] do
        start := first[i];
        next  := first[i+1];
        depthS := depthN;
        depthN := [next..m];
        if not start in avoid then
            #pcgsN := InducedPcgsByPcSequenceNC( pcgs, pcgs{depthN} );
            HmN := pcgsH{Filtered( [1..Length(deptH)],
                         x -> start <= deptH[x] and next > deptH[x] )};
            KmN := pcgsK{Filtered( [1..Length(deptK)],
                         x -> start <= deptK[x] and next > deptK[x] )};

            #pcgsHmN := Concatenation( HmN, pcgsN );
            #pcgsHmN := InducedPcgsByPcSequenceNC( pcgs, pcgsHmN );
            #pcgsHF  := pcgsHmN mod pcgsN;
            #pcgsKmN := Concatenation( KmN, pcgsN );
            #pcgsKmN := InducedPcgsByPcSequenceNC( pcgs, pcgsKmN );
            #pcgsKF  := pcgsKmN mod pcgsN;


            # SumFactorizationFunction takes *LISTS* as arguments 2,3, so we
            # don't need to make pcgs at all.
            #pcgsHF := ModuloTailPcgsByList(pcgs,HmN,[next..m]);
            #pcgsKF := ModuloTailPcgsByList(pcgs,KmN,[next..m]);
            #sum := SumFactorizationFunctionPcgs( pcgs, pcgsHF, pcgsKF, pcgsN );

            # and `SFF' now takes a tail depth, so the expensive sifting to
            # find the identity can be ignored.
            sum := SumFactorizationFunctionPcgs( pcgs, HmN, KmN, next );

            # Maybe there is nothing left to stabilize.
            if Length(x <>IdentityU  ;
                C := ShallowCopy( AsList( A ) );
                D := ShallowCopy( AsList( B ) );
            else
                # GlasbyStabilizer would make a pcgs out of it first anyhow
                B     = ,B ;
                if Length(sum.sum)>0 then
         :  ,d ;
                  pcgsR := java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
                  pcgsR := #  # test if one the groups is known be normal
                  pcgsL:=java.lang.StringIndexOutOfBoundsException: Range [61, 38) out of bounds for length 61
                else
                  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                                               );
                                              #M  NormalIntersection( <G>, <U> )  . . . . . intersection with normal subgrp

                ;

                C := GlasbyStabilizer( pcgs, A, B, pcgsL );
                C :;
                #D := GlasbyShift( C, InducedPcgsByPcSequenceNC(pcgs, B) );
                D :=    home>H) 
D: (AsList   ;
            fi;

            # Now we can cover <C> and <D>.
            return((G(H)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
            A := ShallowCopy( C );
            B := ShallowCopy( D ) ;
        fi;
    od;

    # <A> is the unnormalized intersection.
    new := InducedPcgsByPcSequenceNC( pcgs, A );
    U   := SubgroupByPcgs( G, new );
    return U;
end );


#############################################################################
##
#F  ZassenhausIntersection( pcgs, pcgsN, pcgsU )
##
BindGlobal( "ZassenhausIntersection", function( pcgs, pcgsN, pcgsU )
    local sw, m, ins, g, new;

    if Length(pcgsN)=0 then
      return SubgroupByPcgs( GroupOfPcgs( pcgs ), pcgsN );
    fi;
    # If  <N>  is  composition subgroup, no calculation is needed. We can use
    # weights instead. Otherwise 'IntersectionSumAgGroup' will do the work.
    sw := DepthOfPcElement( pcgs, pcgsN[1] );
    m  := Length( pcgs );
    if pcgs{[sw..m]} = pcgsN then
        ins := [];
        for g in pcgsU do
            if DepthOfPcElement( pcgs, g ) >= sw  then
                Add( ins, g );
            fi;
        od;
        new := InducedPcgsByPcSequenceNC( pcgs, ins );
        ins := SubgroupByPcgs( GroupOfPcgs( pcgs ), new );
        return ins;
    else
        new := ExtendedIntersectionSumPcgs( pcgs, pcgsN, pcgsU, true );
        new := InducedPcgsByPcSequenceNC( pcgs, new.intersection );
        ins := SubgroupByPcgs( GroupOfPcgs( pcgs ), new );
        return ins;
    fi;
end );


#############################################################################
##
#M  Intersection2( <U>, <V> )
##
InstallMethod( Intersection2,
    "groups with pcgs",
    true,
    [ IsGroup and HasHomePcgs,
      IsGroup and HasHomePcgs ],
    0,

function( U, V )
    local G, home, pcgs, pcgsU, pcgsV;

    # Check the parent and catch a trivial case
    home  := HomePcgs(U);
    if home <> HomePcgs(V) then
        TryNextMethod();
    fi;

    # check for trivial cases
    if IsInt(Size(V)/Size(U))
       and ForAll( GeneratorsOfGroup(U), x -> x in V ) then
        return U;
    # here we can test Size(V)<Size(U): if they are the same the test before
    # would have found out.
    elif Size(V)<Size(U) and IsInt(Size(U)/Size(V))
      and ForAll( GeneratorsOfGroup(V), x -> x in U ) then
        return V;
    fi;

    G := GroupOfPcgs(home);
    if Size(U) < GS_SIZE  then
        return SubgroupNC( G, Filtered( AsList(U), x -> x in V and
                                                   x <> Identity(V) ) );
    elif Size(V) < GS_SIZE  then
        return SubgroupNC( G, Filtered( AsList(V), x -> x in U  and
                                                   x <> Identity(U) ) );
    fi;

    # compute nice pcgs's
    pcgs  := SpecialPcgs(home);
    pcgsU := InducedPcgs(pcgs, U );
    pcgsV := InducedPcgs(pcgs, V );

  # disabled calls to `ZassenhausIntersection' that seems to be not
  # applicable. AH, 4/12/05
  #  # test if one the groups is known to be normal
  #  if IsNormal( G, U ) then
  #      return ZassenhausIntersection( pcgs, pcgsU, pcgsV );
  #  elif IsNormal( G, V ) then
  #      return ZassenhausIntersection( pcgs, pcgsV, pcgsU );
  #  fi;

    return GlasbyIntersection( pcgs, pcgsU, pcgsV );

end );

#############################################################################
##
#M  NormalIntersection( <G>, <U> )  . . . . . intersection with normal subgrp
##
InstallMethod( NormalIntersection,
    "method for two groups with home pcgs",
    IsIdenticalObj, [ IsGroup and HasHomePcgs, IsGroup and HasHomePcgs],
function( G, H )
local home;
  home:=HomePcgs(G);
  if home<>HomePcgs(H) then
    TryNextMethod();
  fi;
  return ZassenhausIntersection(home,InducedPcgs(home,G),InducedPcgs(home,H));
end );