This file is indexed.

/usr/share/gap/pkg/Polycyclic/gap/cover/const/orb.gi is in gap-polycyclic 2.11-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
AgOrbitCover := function( A, pt, act )
    local pcgs, rels, orbit, i, y, j, p, l, s, k, t, h;

    pcgs := A.agAutos;
    rels := A.agOrder;

    # initialise orbit
    orbit := [pt];

    # Start constructing orbit.
    i := Length( pcgs );
    while i >= 1 do
        y := act( pt, pcgs[i] );
        j := Position( orbit, y );
        if IsBool( j ) then
            p := rels[i];
            l := Length( orbit );
            orbit[p*l] := true;
            s := 0;
            for k  in [1 .. p-1]  do
                t := s + l;
                for h  in [1..l]  do
                    orbit[h+t] := act( orbit[h+s], pcgs[i] );
                od;
                s := t;
            od;
        fi;
        i := i-1;
    od;

    return orbit;
end;

HybridOrbitCover := function( A, pt, act )
    local block, orbit, new, k, i, j, y;

    # get block
    block := AgOrbitCover( A, pt, act );

    # set up orbit
    orbit := [block];

    # loop
    k := 1;
    while k <= Length( orbit ) do
        for i in [ 1..Length( A.glAutos ) ] do
            y := act( orbit[k][1], A.glAutos[i] );
            j := BlockPosition( orbit, y );
            if IsBool( j ) then
                new := List( orbit[k], x -> act(x, A.glAutos[i]) );
                Add( orbit, new );
            fi;
        od;
        k := k + 1;
        #Print("    OS: sub length ",Length(block)," * ",Length(orbit),"\n");
    od;

    return Concatenation( orbit );
end;

MyOrbits := function( A, len, act )
    local todo, reps, i, c, a, o, j;

    Print("  OS: compute orbits \n");

    # set up boolean list of length len
    todo := []; todo[len] := true; for i in [1..len] do todo[i] := true; od;

    # c is the number of entries true,
    # a+1 is the position of the first true
    c := len; a := 1;

    # set up orbit reps
    reps := [];

    # determine orbits
    while IsInt(a) do

        # store
        Add(reps, a-1);

        # get orbit
        o := HybridOrbitCover( A, a-1, act );

        # cancel in todo-list
        for j in o do
            if j < len then
                if todo[j+1] = false then Error("orb problem"); fi;
                todo[j+1] := false;
                c := c-1;
            fi;
        od;

        a := Position(todo, true, a);

        Print("  OS: orbit length ",Length(o), " -- ",c," to go \n");
    od;

    return reps;
end;