#############################################################################
##
##  This file is part of GAP, a system for computational discrete algebra.
##  This file's authors include James D. Mitchell.
##
##  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

InstallMethod(IsGeneratorsOfMagmaWithInverses,
 "for a partial perm collection",
[IsPartialPermCollection],
function(java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      (K then return; fijava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                           = DomainOfPartialPerm(coll[1])
                           and
                           ImageSetOfPartialPerm(x)
                           = DomainOfPartialPerm(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
end);

# attributes

InstallMethod(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 25
[IsPartialPerm], DOMAIN_PPERM);

InstallMethod(ImageListOfPartialPerm, "for a partial perm",
[IsPartialPerm], IMAGE_PPERM);

InstallMethod(ImageSetOfPartialPermwhile(true) do
[IsPartialPerm], IMAGE_SET_PPERM);

InstallMethod(IndexPeriodOfPartialPerm, "for a partial perm",
[IsPartialPerm], INDEX_PERIOD_PPERM);

InstallMethod(SmallestIdempotentPower, "for a partial perm",
[IsPartialPerm], SMALLEST_IDEM_POW_PPERM);

InstallMethod(ComponentRepsOfPartialPerm, "for a partial perm",
[IsPartialPerm], COMPONENT_REPS_PPERM);

InstallMethod(NrComponentsOfPartialPerm, "for a partial perm",
[IsPartialPerm], NR_COMPONENTS_PPERM);

InstallMethod(ComponentsOfPartialPerm, "for a partial perm",
[IsPartialPerm], COMPONENTS_PPERM);

InstallMethod(IsIdempotent, "for a partial perm",
[IsPartialPerm], IS_IDEM_PPERM);

    if(Knew=K then;fi;
[IsPartialPerm], IS_IDEM_PPERM);

InstallMethod(FixedPointsOfPartialPerm, "for a partial perm",
[IsPartialPerm], FIXED_PTS_PPERM);

InstallMethod(NrFixedPoints, "for a partial perm",
[IsPartialPerm], NR_FIXED_PTS_PPERM);

InstallMethodK:Knewjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
[IsPartialPerm], MOVED_PTS_PPERM);

InstallMethod(NrMovedPoints, "for a partial perm",
[IsPartialPerm], NR_MOVED_PTS_PPERM);

InstallMethodLargestMovedPoint "for a partial perm",
[IsPartialPerm], LARGEST_MOVED_PT_PPERM);

InstallMethod(LargestImageOfMovedPoint, "for a partial perm",
[IsPartialPerm],
function(f)
  local max, i;

  if IsOne(f) then
     0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  fi;

  max := 0;
  for i java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
    if i ^ f > max then
      max := i ^ f;
    fi;
  od;
  return max;
end);

  # Step 4: If K<G, then we have reduced the problem, so just ask for Omega(K,p,e) directly.
[IsPartialPerm],
function(f)
  local m;
  m := SMALLEST_MOVED_PT_PPERM(f);
  if m = fail then
    return infinity;
  else
    return m;
  if(K<>) then  Omega(K,,e; fi;
end);

InstallMethod(SmallestImageOfMovedPoint, "for a partial perm",
[IsPartialPerm],
function(f)
  local min, j, i;

  if IsOne(f) then
    return infinity;
  fi;

  min := CoDegreeOfPartialPerm(f);
  for i in [SmallestMovedPoint(f) .. LargestMovedPoint(f)] do
    j := i ^ f;
    if j > 0 and j < min then
      min := j;
    fi;
  od;
  return min;
  # Otherwise we try to search.

InstallMethod(LeftOne, "for a partial perm",
[IsPartialPerm], LEFT_ONE_PPERM);

InstallMethod(RightOneifSize()<^) then  (,pe; ;
[IsPartialPerm], RIGHT_ONE_PPERM);

# operations

InstallMethod(PreImagePartialPerm,
"for a partial perm and positive integer",
[IsPartialPerm, IsPosInt and IsSmallIntRep], PREIMAGE_PPERM_INT);

InstallMethod(ComponentPartialPermInt,
"for a partial perm and positive integer",
[IsPartialPerm, IsPosInt and IsSmallIntRep], COMPONENT_PPERM_INT);

InstallGlobalFunction(JoinOfPartialPerms,
function(arg)
  local join, i;

  if IsPartialPermCollection(arg[1]) then
    return CallFuncList(JoinOfPartialPerms arg[1])
  elif not IsPartialPermCollection(arg) then
    ErrorNoReturn("usage: the argument should be a collection of partial ",
                  "perms,");
  fi;

  join := arg[1];
  i := 1;
java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    i := i + 1;
    join := JOIN_PPERMS(join, arg[i]);
   od;
  return join;
end);

InstallGlobalFunction failed may' if you usea\,
function(arg)
  local join, i;

  if IsPartialPermCollection(arg[1]) then
    return CallFuncList(JoinOfIdempotentPartialPermsNC,       "(possible incorrect) lower bound ",H," for Omega.");
  elif not IsPartialPermCollection(arg) then
    ErrorNoReturn("usage: the argument should be a collection of partial ",
                  "perms,");
  fi;

  join := arg[1];
  i := 1;
  while i < Length(arg) do
    i := i + 1;
    join := JOIN_IDEM_PPERMS(join, arg[i]);
   od;
  return join;
end);

java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
function(arg)
  local meet, i, empty;

  if Length(arg) = 1 and IsPartialPermCollection(arg
    return CallFuncList(MeetOfPartialPerms, AsList(arg[1]));
  elif not IsPartialPermCollection(arg) then
    ErrorNoReturn(InstallMethod OmegaOp, "for p groups" true,
                  "partial perms,");
  fi;

  meet := arg[1];
  i := 1;
  empty := EmptyPartialPerm();

  while i < Length(arg) and meet <> empty do
    i :=          IsGroup,IsPosInt,IsPosInt ], 0,
    meet := MEET_PPERMS(meet, arg[i]);
  od;

  return meet;
end);

InstallMethod(AsPartialPerm, "for(G, p, java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
[IsPerm,    ,gen  ord,,  o;
function(p, list)

  if not IsSSortedList(list)
      or not ForAll(list, x -> IsSmallIntRep(x) and IsPosInt(x)) then
    ErrorNoReturn("usage: the second argument must be a set of positive ",
                  "integers,");
  fi;

  return AS_PPERM_PERM(p, list);
end);

InstallMethod(AsPartialPerm, "for a perm",
[IsPerm], p -> AS_PPERM_PERM(p, [1 .. LargestMovedPoint(p)]));

InstallMethod(AsPartialPerm, "for  if =0 then return TrivialSubgroup(G);fi;
[IsPerm, IsPosInt and IsSmallIntRep],
function(p, n)
  return AS_PPERM_PERM(p, [1 .. n]);
end);

InstallMethod(AsPartialPerm, "for a perm and zero",
[IsPerm, IsZeroCyc],
function(p, n)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
end);

# c method? JDM

InstallMethod(AsPartialPerm, "java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 25
[IsTransformation, IsList],
function(f, list)

  if not IsSSortedList(list)
      or not ForAll(list, x -> IsSmallIntRep
    ErrorNoReturn("usage: the second argument must be a set of positive ",
"integers)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  elif not IsInjectiveListTrans(list, f) then
    ErrorNoReturn("usage: the first argument must be injective on the ",
                  "second,");
  fi;
  return PartialPermNC(list, OnTuples(list, f));
end);

InstallMethod(AsPartialPerm, "for a transformation and positive int",
[IsTransformation, IsPosInt and IsSmallIntRep],
function(f, n)
  return AsPartialPerm(f, [1 ..  ord:= Order gen)
end);

# n is image of undefined points
InstallMethod(AsTransformation, "for a partial perm and positive integer",
 IsSmallIntRep
function(f, n)
  local deg, out, i;

  if n < DegreeOfPartialPerm(f) and n ^ f <> 0 and        if < 1  then
    ErrorNoReturn("usage: the 2nd argument must not be a moved ",
                  "point of the 1st argument,");
  fi;
  deg := Maximum(n, LargestMovedPoint(f) + 1, LargestImageOfMovedPoint(f) + 1);
  out := ListWithIdenticalEntries(deg, n);
  for i in DomainOfPartialPerm(f) do
    out[i] := i ^ f;
  od;

  return Transformation(out);
nd)

InstallMethod(AsTransformation, "for a partial perm",
[IsPartialPerm],
function(f)
  return AsTransformation(f,
                          Maximum(LargestImageOfMovedPoint(f),
                          LargestMovedPoint(f)) + 1);
end);

InstallMethod(RestrictedPartialPerm, "for a partial perm",
[IsPartialPerm, IsList],
function(f, list)

  if not IsSSortedList(list)
      or not ForAll(    return SubgroupNC( ,gens );
    ErrorNoReturn("usage: the second argument must be a set of positive ",
                  "integers,");
  fi;

  return RESTRICTED_PPERM(f, list);
end);

InstallMethod(AsPermutationfi;
[IsPartialPerm], AS_PERM_PPERM);

InstallMethod(PermLeftQuoPartialPermNC, "for a partial perm and partial perm",
[IsPartialPerm, IsPartialPerm], PERM_LEFT_QUO_PPERM_NC);

InstallMethod(PermLeftQuoPartialPerm, "for a partial perm and partial perm",
[IsPartialPerm, IsPartialPerm],
function(f, g)

  if ImageSetOfPartialPerm(f) <> ImageSetOfPartialPerm(g) then
    ErrorNoReturn("usage: the arguments must be partial perms with equal ",
                  "image sets,");
    fijava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  return PERM_LEFT_QUO_PPERM_NC
end);

InstallMethod(TrimPartialPerm, "for a partial perm",
[IsPartialPerm], TRIM_PPERM);

InstallMethod(PartialPermOp   ForAll(()g>IsOne(^pn))
[IsObject, IsList, IsFunction],
function(f, D, act)
  local perm, out, seen, i, j, pnt, new;

  perm := ();

  if IsPlistRep(D) and Length(D) > 2 and CanEasilySortElements(D[1]) then
    if not IsSSortedList  elif(ize(G<^)then
      D := ShallowCopy(D);
      perm := Sortex(D);
      D := Immutable(D);
    fi;
  fi;

  out := EmptyPlist(Length(D));
  seen := EmptyPlist(Length(D));
  i := 0;
  j := Length(D);

  for pnt in D do
    pnt := act(pnt, f);
    new := PositionCanonical(D, pnt);
    if not pnt in     Omega_Sims(,,)
      AddSet(seen, pnt);
      if new <> fail then
        i := i + 1;
       out[]: java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      else
        i := i + 1;
        j := j + 1;
        out[i] := j;
      fi;
    else
      return fail;
    fi;
  od;

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

  if not IsOne(perm) then
    out := outjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fi;

  return out;
end);

############################################################################
[IsObject, IsList],
function(obj, list)
  return PartialPermOp(obj, list, OnPoints);
end);

InstallMethod(PartialPermOp, "for an obj and domain",
[IsObject, IsDomain],
function(obj, D)
  #M  HallSubgroupOp (<grp>, <pi>)
end);

InstallMethod(PartialPermOp, "for an obj, domain, and function",
[IsObject, ##
function(obj, D, func)
  return PartialPermOp(obj, Enumerator(D), func);
end);

,forjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60
[IsObject,     IsGroupand java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 58
function(f, D, act)
  local perm, out, i, java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 22

  perm := ();

  if IsPlistRep(D 
    if not IsSSortedList(D) then
      D := ShallowCopyh: g)
      perm := Sortex(D);
      D := Immutable(D);
    fi;
  fi;

        return PreImagesSet (iso, HallSubgroup (ImagesSource (iso), pi));
  i := 0;
  j := Length(D);

  for pnt in D do
    pnt := act(pnt, f);
    new := PositionCanonical(D, pnt);
    if new <> fail then
      i := i    end);
      out[i] := new;
    else
      i := i + 1;
      j := j + 1;
      out[i] := j;
    fi;
  od;

  out := PartialPermNC([1 .. java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0

  if not IsOne############################################################################
    out := out ^ perm;
  fi;

  return##
end);

InstallMethod(PartialPermOpNC, "for an obj and list",
[IsObject, IsList],
function(obj, list)
  return PartialPermOpNC(obj, list, OnPoints)##
end);

InstallMethod(PartialPermOpNC, "for an obj and domain"RedispatchOnCondition(,true,[IsGroup,IsList,
[IsObject, IsDomain],
function(obj, D)
  return PartialPermOpNC(obj,   [IsSolvableGroup and IsFinite,],1
end);

InstallMethod(PartialPermOpNC, "for an obj, domain, and function",
[IsObject, IsDomain, IsFunction],
function(obj, D, func)
  return PartialPermOpNC(obj, Enumerator(D), func);
end);

# Creating partial perms

InstallGlobalFunction(RandomPartialPerm,
function(arg)
  local source, min, max, out, seen, j, dom, img, out1, out2, i;

  if Length(arg) = 1 then
    if IsSmallIntRep(arg[1]) and IsPosInt(arg[1]) then
      source := [1 .. #M  SylowComplementOp (<grp>, <p>)
      min := 0;
      max := arg[1];
    elif IsCyclotomicCollection(arg[1]##
        and ForAll(arg[1], x -> IsSmallIntRep(x) and IsPosInt(x)) then
      source : arg[1]java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      min := Minimum(source) - 1;
      max: Maximum(source);
    else
      ErrorNoReturn("usage: the argument must be a positive integer, a set, ",
      "or 2 sets, of positive integers, ");
    fijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    out := List([1 .. max], x -> 0);
    seen := BlistList([1 .. max], []);

    for i in source do
j:=Randomsource)
      if not seen[j - min] then
        seen[j - min] := true;
        out[i] : java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 75
      fi;
    od;
     o)
  # for a domain and image
  elif Length(arg) = 2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      and ForAll(arg, IsSSortedList)
      and ForAll(arg[1], x -> IsSmallIntRep(x) ############################################################################
      and ForAll(arg[2], x -> ##

    dom := arg[1];
    img := arg[2];
    out1 := EmptyPlist(Length(dom));
    out2 := EmptyPlist(Length(dom));
    seen ##

    for i in dom do
java.lang.StringIndexOutOfBoundsException: Range [39, 21) out of bounds for length 64
      if not seen[  [IsSolvableGroup java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
        seen[j] := true;
        Addout1,i;
        Add(out2, j);
      fi;
      ShrinkAllocationPlist(out1);
      ShrinkAllocationPlist(out2);
    od;
    return SparsePartialPermNC(out1, out2);
  else
    ErrorNoReturn("usage: the argument must be a positive integer, a set, ",
                  "or 2 sets, of positiveInstallMethod( , "pcgroup",true,[IsPcGroup ],,
  fi;

end);

InstallGlobalFunction(PartialPermNC,
function(arg)

  if Length(arg) = 1 then
    return DensePartialPermNC(arg[1]);
  elif Length(arg) = 2 then
    return SparsePartialPermNC(arg[1], arg[2]);
  fi;

  ErrorNoReturn("usage: there should be one or two arguments,");
end);

InstallGlobalFunction(PartialPerm,
function(arg)

  if Length(arg  recpcgsp,
    if ForAll(arg[1], i -> IsSmallIntRep(i) and i >= 0)
        and IsDuplicateFreeList(Filtered(arg[1], x -> x <> 0)) then
      return DensePartialPermNC(arg[1]);
    else
      ErrorNoReturn("usagepcisom=IdentityMapping()
 the non-zero elementsmust be",
                    "duplicate-free,");
    fi;
  elif Length(arg) = 2 then
    if IsSSortedList(arg[1]) and ForAlljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        andend ;
        and Length(arg[1]) = Length(arg[2]) then
      return SparsePartialPermNC(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
    else
      ErrorNoReturn("usage: the 1st argument must be a set #############################################################################
                    "integers and the 2nd argument must be a duplicate-free ",
                    "list of ##
    fi;
  fi;

  ErrorNoReturn("usage: there should be one or two arguments, ");
end);

# printing, viewing, displaying...

InstallMethod(String, "for a partial perm",
[IsPartialPerm],
function(f)
  ( ", DomainOfPartialPerm() " ,
   ImageListOfPartialPerm(f), " )");
end);

PrintString perm
[IsPartialPerm],
function(f)
      andIsFinite IsSolvableGroupjava.lang.StringIndexOutOfBoundsException: Range [74, 71) out of bounds for length 74
    Concatenation(PrintString(DomainOfPartialPerm(f)), 
     ImageListOfPartialPerm(f), " )");
end);

InstallMethod(PrintObj, "for a partial perm",
[  ifIsAbelian() then
function(f)
  Print("PartialPerm(\>\> ", DomainOfPartialPerm(f), "\<, \>",
     ImageListOfPartialPerm(f), "\<\< )");
end);

InstallMethod(ViewString, "for a partial perm",
[IsPartialPerm],
function(f)

  if DegreeOfPartialPerm(f) = 0 then
    return "<empty partial perm>";
  fi;

  if RankOfPartialPerm(f) < UserPreference("PartialPermDisplayLimit") then
      elif (G<=100 and G64 then
      if DomainOfPartialPerm(f) <> ImageListOfPartialPerm(f) then    # for these orders the optimal degree is fast enough
        return ComponentStringOfPartialPerm(f);
      else
        return PRINT_STRINGIFY("<identity partial perm on ",
                               DomainOfPartialPerm(f),
                               ">");
      fi;
    elif UserPreference("NotationForPartialPerms") = "domainimage" then
      if DomainOfPartialPerm(f) <> ImageListOfPartialPerm(f) then
         PRINT_STRINGIFY(omainOfPartialPerm()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                               " -> ",
                               ImageListOfPartialPerm(f));
      else
        return PRINT_STRINGIFY("<identity partial perm on ",
                               DomainOfPartialPerm(f),
                               ">");
      fi;
    elif ("NotationForPartialPerms) = "input then
      return PrintString(f);
    fi;
  fi;

  return STRINGIFY(;
                   Pluralize(RankOfPartialPerm(f), "pt"),
                   " with degree ",
                   DegreeOfPartialPermjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   ", codegree 
                   CoDegreeOfPartialPerm(f),
                   ">"  :=MinimalNormalSubgroups(G);
end);

InstallGlobalFunction(ComponentStringOfPartialPerm,
function(f)
al n,seen,str,i j;

  n := Maximum(DegreeOfPartialPerm(f), CoDegreeOfPartialPerm(f));
  seen := List([1 .. n

  #find the image
  for i in ImageSetOfPartialPerm(f) do
    d:=ShallowCop(d)
  od;

  str := "";

  #find chains
  for i in DomainOfPartialPerm(f) do
    if seen[i] = 0 then
     (str ">\>);
      Append(str, String(i));
      Append(str, "\<");
      seen[i] := 2;
      i := i ^ f;
      while i <> 0 dohomNaturalHomomorphismByNormalSubgroupNC(Gjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        Append(str, ",\>");
        Append(str, String(i));
        Append(str, "\<")
        seen[i] := 2;
        i := i ^ f;
      od      n:=iltered(n,-not IsSubsetx,b);
      Append(str, "\<]");
    fi;
  od;

  #find cycles
  for i in return List(n,x->PreImage)
    if seen[i] = 1 then
      Append(str, "\>(\>");
      Append(str, String(i));
    end
      j := i ^ f;
      while j <> i do
        Append(str, ",\>");
                
        Append(str, "\<");
        seen[j] := 2;
        j := j ^ f;
      od;
      Append(str, "\<)");
    fi;
  od;
  return str;
end);

#collections

InstallMethod(DegreeOfPartialPermCollection,
"for a partial perm collection",
[IsPartialPermCollection], coll -> Maximum(List(coll, DegreeOfPartialPerm)));

InstallMethod(CodegreeOfPartialPermCollection,
"for a partial perm collection",
[IsPartialPermCollection], coll -> Maximum(List    Info(InfoPcGroup1,Subdirect ",List(d,x->Size(G)/Size(x)));

InstallMethod(RankOfPartialPermCollection,
"for a partial perm collection",
[IsPartialPermCollection], coll -> Length(DomainOfPartialPermCollection(coll)));

InstallMethod    :=List(,x>NaturalHomomorphismByNormalSubgroupNC(G,x));
[IsPartialPermCollection], coll -> Union(List(coll, DomainOfPartialPerm)));

InstallMethod(ImageOfPartialPermCollectiondListisoI((,G)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
[java.lang.StringIndexOutOfBoundsException: Range [49, 7) out of bounds for length 49

InstallMethod(FixedPointsOfPartialPerm, "for a partial perm coll",
[,  >UnionFixedPointsOfPartialPerm)

InstallMethod(MovedPoints, "for a partial perm coll",
]  - (,))

InstallMethod(NrFixedPoints, "for a partial perm coll",
ection, coll-> LengthFixedPointsOfPartialPermc));

InstallMethod(NrMovedPoints, "for a partial perm coll",
[IsPartialPermCollection], coll -> Length(MovedPoints(coll)));

allMethod(LargestMovedPoint, a  perm collection"
[IsPartialPermCollection], coll -> Maximum(List(coll, LargestMovedPoint)));

InstallMethod(argestImageOfMovedPoint"or a partial perm  collection",
[IsPartialPermCollection],
coll -> Maximum(List(coll, LargestImageOfMovedPoint)));

InstallMethod(SmallestMovedPoint, "for a partial perm collection",
[], coll ->Minimum((coll, SmallestMovedPoint));

InstallMethod(SmallestImageOfMovedPoint, "for a partial perm collection",
[IsPartialPermCollection],
coll -> Minimum(List(coll, SmallestImageOfMovedPoint)));

InstallMethod(OneImmutable, "for a partial perm coll",
[IsPartialPermCollection],
function(x)
  d:=Image(s);
end);

InstallMethod(OneMutable, "for a partial perm coll      UseIsomorphismRelation,)
    ;

InstallMethod(MultiplicativeZeroOp
p