/usr/share/gap/lib/partitio.gd is in gap-libs 4r7p5-2.
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 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 | #############################################################################
##
#W partitio.gd GAP library Heiko Theißen
##
##
#Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany
#Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland
#Y Copyright (C) 2002 The GAP Group
##
#############################################################################
##
#F Partition( <list> ) . . . . . . . . . . . . . . . . partition constructor
##
DeclareGlobalFunction("Partition");
#############################################################################
##
#F PartitionSortedPoints( <list> )
##
DeclareGlobalFunction("PartitionSortedPoints");
#############################################################################
##
#F IsPartition( <P> ) . . . . . . . . . . . . test if object is a partition
##
DeclareGlobalFunction( "IsPartition" );
#T state this in the definition of a partition!
#############################################################################
##
#F NumberCells( <P> ) . . . . . . . . . . . . . . . . . . . number of cells
##
DeclareGlobalFunction( "NumberCells" );
#############################################################################
##
#F Cell( <P>, <m> ) . . . . . . . . . . . . . . . . . . . . . cell as list
##
DeclareGlobalFunction( "Cell" );
#############################################################################
#F Cells( <Pi> ) . . . . . . . . . . . . . . . . . partition as list of sets
##
DeclareGlobalFunction( "Cells" );
#############################################################################
##
#F CellNoPoint( <part>,<pnt> )
##
## Number of cell that contains <pnt>.
##
DeclareGlobalFunction("CellNoPoint");
#############################################################################
##
#F PointInCellNo( <part>,<pnt>,<no> )
##
## Is <pnt> in cell <no> of <part>?
##
DeclareGlobalFunction("PointInCellNo");
#############################################################################
##
#F CellNoPoints( <part>,<pntlst> )
##
## Numbers of cell that contains <pntlst>.
##
DeclareGlobalFunction("CellNoPoints");
#############################################################################
##
#F Fixcells( <P> ) . . . . . . . . . . . . . . . . . . . . fixcells as list
##
## Returns a list of the points along in their cell, ordered as these cells
## are ordered
##
DeclareGlobalFunction( "Fixcells" );
#############################################################################
##
#F SplitCell( <P>, <i>, <Q>, <j>, <g>, <out> ) . . . . . . . . split a cell
##
## Splits <P>[ <i> ], by taking out all the points that are also contained
## in <Q>[ <j> ] ^ g. The new cell is appended to <P> unless it would be
## empty. If the old cell would remain empty, nothing is changed either.
##
## Returns the length of the new cell, or `false' if nothing was changed.
##
## Shortcuts of the splitting algorithm: If the last argument <out> is
## `true', at least one point will move out. If <out> is a number, at most
## <out> points will move out.
##
DeclareGlobalFunction( "SplitCell" );
#############################################################################
##
#F IsolatePoint( <P>, <a> ) . . . . . . . . . . . . . . . . isolate a point
##
## Takes point <a> out of its cell in <P>, putting it into a new cell, which
## is appended to <P>. However, does nothing, if <a> was already isolated.
##
## Returns the number of the cell from <a> was taken out, or `false' if
## nothing was changed.
##
DeclareGlobalFunction( "IsolatePoint" );
#############################################################################
##
#F UndoRefinement( <P> ) . . . . . . . . . . . . . . . . . undo a refinement
##
## Undoes the effect of the last cell-splitting actually performed by
## `SplitCell' or `IsolatePoint'. (This means that if the last call of such
## a function had no effect, `UndoRefinement' looks at the second-last etc.)
## This fuses the last cell of <P> with an earlier cell.
##
## Returns the number of the cell with which the last cell was fused, or
## `false' if the last cell starts at `<P>.points[1]', because then it
## cannot have been split off.
##
## May behave undefined if there was no splitting before.
##
DeclareGlobalFunction( "UndoRefinement" );
#############################################################################
##
#F FixpointCellNo( <P>, <i> ) . . . . . . . . . fixpoint from cell no. <i>
##
## Returns the first point of <P>[ <i> ] (should be a one-point cell).
##
DeclareGlobalFunction( "FixpointCellNo" );
#############################################################################
##
#F FixcellPoint( <P>, <old> ) . . . . . . . . . . . . . . . . . . . . local
##
## Returns a random cell number which is not yet contained in <old> and has
## length 1.
##
## Adds this cell number to <old>.
##
DeclareGlobalFunction( "FixcellPoint" );
#############################################################################
##
#F FixcellsCell( <P>, <Q>, <old> ) . . . . . . . . . . . local
##
## Returns [ <K>, <I> ] such that for j=1,...|K|=|I|, all points in cell
## <P>[ <I>[j] ] have value <K>[j] in <Q.cellno> (i.e.,
## lie in cell <K>[j] of the partition <Q>.
## Returns `false' if <K> and <I> are empty.
##
DeclareGlobalFunction( "FixcellsCell" );
#############################################################################
##
#F TrivialPartition( <Omega> ) . . . . . . . . . one-cell partition of a set
##
DeclareGlobalFunction( "TrivialPartition" );
#############################################################################
##
#F OrbitsPartition( <G>, <Omega> ) partition determined by the orbits of <G>
##
DeclareGlobalFunction( "OrbitsPartition" );
#############################################################################
##
#F SmallestPrimeDivisor( <size> ) . . . . . . . . . smallest prime divisor
##
DeclareGlobalFunction( "SmallestPrimeDivisor" );
#############################################################################
##
#F CollectedPartition( <P>, <size> ) . orbits on cells under group of <size>
##
## Returns a partition into unions of cells of <P> of equal length, sorted
## by this length. However, if there are $n$ cells of equal length, which
## cannot be fused under the action of a group of order <size> (because $n$
## < SmallestPrimeDivisor( <size> )), leaves these $n$ cells unfused.
## (<size> = 1 suppresses this extra feature.)
##
DeclareGlobalFunction( "CollectedPartition" );
#############################################################################
##
#E
|