utils-0.93/ 0000755 0001751 0001751 00000000000 15105376105 012216 5 ustar runner runner utils-0.93/doc/ 0000755 0001751 0001751 00000000000 15105376105 012763 5 ustar runner runner utils-0.93/doc/manual.lab 0000644 0001751 0001751 00000016315 15105376105 014726 0 ustar runner runner \GAPDocLabFile{utils}
\makelabel{utils:Title page}{}{X7D2C85EC87DD46E5}
\makelabel{utils:Abstract}{}{X7AA6C5737B711C89}
\makelabel{utils:Copyright}{}{X81488B807F2A1CF1}
\makelabel{utils:Acknowledgements}{}{X82A988D47DFAFCFA}
\makelabel{utils:Table of Contents}{}{X8537FEB07AF2BEC8}
\makelabel{utils:Introduction}{1}{X7DFB63A97E67C0A1}
\makelabel{utils:Information for package authors}{1.1}{X8508AD637B79CEE8}
\makelabel{utils:Printing Lists and Iterators}{2}{X83686EE47E4D4F66}
\makelabel{utils:Printing selected items}{2.1}{X7F6817927F86240F}
\makelabel{utils:Lists, Sets and Strings}{3}{X7AE6EFC086C0EB3C}
\makelabel{utils:Functions for lists}{3.1}{X7C3F1E7D878AAA65}
\makelabel{utils:Distinct and Common Representatives}{3.2}{X82F443FF84B8FCE3}
\makelabel{utils:Functions for strings}{3.3}{X8033A2FE80FC2F2A}
\makelabel{utils:Number-theoretic functions}{4}{X86E71C1687F2D0AD}
\makelabel{utils:Functions for integers}{4.1}{X7D33B5B17BF785CA}
\makelabel{utils:Groups and homomorphisms}{5}{X8171DAF2833FF728}
\makelabel{utils:Functions for groups}{5.1}{X7E21E6D285E6B12C}
\makelabel{utils:Left Cosets for Groups}{5.2}{X7FE4848B7DE6B3FD}
\makelabel{utils:Inverse}{5.2.2}{X793E48267EF5FD77}
\makelabel{utils:Functions for group homomorphisms}{5.3}{X80A512877F515DE7}
\makelabel{utils:Matrices}{6}{X812CCAB278643A59}
\makelabel{utils:Some operations for matrices}{6.1}{X802118FB7C94D6BA}
\makelabel{utils:Iterators}{7}{X85A3F00985453F95}
\makelabel{utils:Some iterators for groups and their isomorphisms}{7.1}{X7BB5350081B27D17}
\makelabel{utils:Operations on iterators}{7.2}{X85413EED812C6497}
\makelabel{utils:Records}{8}{X7AA1073C7E943DD7}
\makelabel{utils:Functions for records}{8.1}{X82B3D1D583CDF0E5}
\makelabel{utils:Option records for functions}{8.2}{X7E6207B47B9AA30C}
\makelabel{utils:Web Downloads}{9}{X815B0C4B7EBE6E1E}
\makelabel{utils:Functions for downloading files from the web}{9.1}{X8758CB7F79EFB6ED}
\makelabel{utils:User preference DownloadVerifyCertificate}{9.1.2}{X85182BA486E3C2AA}
\makelabel{utils:User preference DownloadMaxTime}{9.1.3}{X79E10E5B83EF929F}
\makelabel{utils:Various other functions}{10}{X83EFC3178180D918}
\makelabel{utils:File operations}{10.1}{X81A0A4FF842B039B}
\makelabel{utils:LaTeX strings}{10.2}{X84D2922D87EDE9E9}
\makelabel{utils:Conversion to Magma strings}{10.3}{X79F021B1830B68F6}
\makelabel{utils:Obsolete functions}{11}{X7F561B1D803182FF}
\makelabel{utils:Operations from AutoDoc}{11.1}{X7A6BB3D084912F35}
\makelabel{utils:Functions for printing}{11.2}{X86F322FC7DECE36F}
\makelabel{utils:Other obsolete functions}{11.3}{X84A4F0B281FA0F94}
\makelabel{utils:Applicable Methods}{11.3.1}{X78B7D1A982BE9866}
\makelabel{utils:ExponentOfPrime}{11.3.2}{X7C1AF2467FB55D79}
\makelabel{utils:The transfer procedure}{12}{X84AC9613842F014C}
\makelabel{utils:Bibliography}{Bib}{X7A6F98FD85F02BFE}
\makelabel{utils:References}{Bib}{X7A6F98FD85F02BFE}
\makelabel{utils:Index}{Ind}{X83A0356F839C696F}
\makelabel{utils:GitHub repository}{1}{X7DFB63A97E67C0A1}
\makelabel{utils:PrintSelection for a list of positions}{2.1.1}{X784638AC84D49870}
\makelabel{utils:PrintSelection for a first item and a step}{2.1.1}{X784638AC84D49870}
\makelabel{utils:DifferencesList}{3.1.1}{X78B7C92681D2F13C}
\makelabel{utils:QuotientsList}{3.1.2}{X7975371E865B89BC}
\makelabel{utils:FloatQuotientsList}{3.1.2}{X7975371E865B89BC}
\makelabel{utils:SearchCycle}{3.1.3}{X86096E73858CFABD}
\makelabel{utils:RandomCombination}{3.1.4}{X7EF06CAD7F35245D}
\makelabel{utils:distinct and common representatives}{3.2}{X82F443FF84B8FCE3}
\makelabel{utils:DistinctRepresentatives}{3.2.1}{X78105CAA847A888C}
\makelabel{utils:CommonRepresentatives}{3.2.1}{X78105CAA847A888C}
\makelabel{utils:CommonTransversal}{3.2.1}{X78105CAA847A888C}
\makelabel{utils:IsCommonTransversal}{3.2.1}{X78105CAA847A888C}
\makelabel{utils:BlankFreeString}{3.3.1}{X870C964E7804B266}
\makelabel{utils:AllSmoothIntegers for two integers}{4.1.1}{X8191A031788AC7C0}
\makelabel{utils:AllSmoothIntegers for a list and an integer}{4.1.1}{X8191A031788AC7C0}
\makelabel{utils:smooth integer}{4.1.1}{X8191A031788AC7C0}
\makelabel{utils:AllProducts}{4.1.2}{X78BE6B8B878D250D}
\makelabel{utils:RestrictedPartitionsWithoutRepetitions}{4.1.3}{X845F46E579CEA43F}
\makelabel{utils:NextProbablyPrimeInt}{4.1.4}{X81708BF4858505E8}
\makelabel{utils:PrimeNumbersIterator}{4.1.5}{X8021EEE5787FCA37}
\makelabel{utils:Comm}{5.1.1}{X80761843831B468E}
\makelabel{utils:IsCommuting}{5.1.2}{X803A050C7A183CCC}
\makelabel{utils:ListOfPowers}{5.1.3}{X87A8F01286548037}
\makelabel{utils:GeneratorsAndInverses}{5.1.4}{X820B71307E41BEE5}
\makelabel{utils:UpperFittingSeries}{5.1.5}{X84CF95227F9D562F}
\makelabel{utils:LowerFittingSeries}{5.1.5}{X84CF95227F9D562F}
\makelabel{utils:FittingLength}{5.1.5}{X84CF95227F9D562F}
\makelabel{utils:Fitting series}{5.1.5}{X84CF95227F9D562F}
\makelabel{utils:LeftCoset}{5.2.1}{X8340B4537F17DCD3}
\makelabel{utils:EpimorphismByGenerators}{5.3.1}{X80C9A0B583FEA7B9}
\makelabel{utils:Pullback}{5.3.2}{X7C705F2A79F8E43C}
\makelabel{utils:PullbackInfo}{5.3.2}{X7C705F2A79F8E43C}
\makelabel{utils:CentralProduct}{5.3.3}{X78DD2C617B992BE2}
\makelabel{utils:CentralProductInfo}{5.3.3}{X78DD2C617B992BE2}
\makelabel{utils:IdempotentEndomorphisms}{5.3.4}{X801038CB808FC956}
\makelabel{utils:IdempotentEndomorphismsData}{5.3.4}{X801038CB808FC956}
\makelabel{utils:IdempotentEndomorphismsWithImage}{5.3.4}{X801038CB808FC956}
\makelabel{utils:DirectProductOfFunctions}{5.3.5}{X81FA9E6C7F3B9238}
\makelabel{utils:DirectProductOfAutomorphismGroups}{5.3.6}{X7CB2D5F27F4182AF}
\makelabel{utils:DirectSumDecompositionMatrices}{6.1.1}{X787B89237E1398B6}
\makelabel{utils:Iterators}{7.1}{X7BB5350081B27D17}
\makelabel{utils:AllIsomorphismsIterator}{7.1.1}{X7F8B54D1806C762D}
\makelabel{utils:AllIsomorphismsNumber}{7.1.1}{X7F8B54D1806C762D}
\makelabel{utils:AllIsomorphisms}{7.1.1}{X7F8B54D1806C762D}
\makelabel{utils:AllSubgroupsIterator}{7.1.2}{X831DA5AE8437578F}
\makelabel{utils:CartesianIterator}{7.2.1}{X87395A9181A35301}
\makelabel{utils:UnorderedPairsIterator}{7.2.2}{X7C95E27987A812EA}
\makelabel{utils:AssignGlobals}{8.1.1}{X84D82EB579B2ACCD}
\makelabel{utils:OptionRecordWithDefaults}{8.2.1}{X8322B9377CC590D2}
\makelabel{utils:Download}{9.1.1}{X7A7438AE8448635E}
\makelabel{utils:DownloadVerifyCertificate}{9.1.2}{X85182BA486E3C2AA}
\makelabel{utils:DownloadMaxTime}{9.1.3}{X79E10E5B83EF929F}
\makelabel{utils:Log2HTML}{10.1.1}{X7B7ECADF85F748BE}
\makelabel{utils:IntOrOnfinityToLaTeX}{10.2.1}{X87DEB2B58266F858}
\makelabel{utils:LaTeXStringFactorsInt}{10.2.2}{X7DC642B97CD02F4E}
\makelabel{utils:ConvertToMagmaInputString}{10.3.1}{X8768D7707B4CBBD4}
\makelabel{utils:PermGroupToMagmaFormat}{10.3.1}{X8768D7707B4CBBD4}
\makelabel{utils:PcGroupToMagmaFormat}{10.3.1}{X8768D7707B4CBBD4}
\makelabel{utils:MatrixGroupToMagmaFormat}{10.3.1}{X8768D7707B4CBBD4}
\makelabel{utils:FindMatchingFiles}{11.1}{X7A6BB3D084912F35}
\makelabel{utils:CreateDirIfMissing}{11.1}{X7A6BB3D084912F35}
\makelabel{utils:StringDotSuffix}{11.1}{X7A6BB3D084912F35}
\makelabel{utils:GetSuffix}{11.1}{X7A6BB3D084912F35}
\makelabel{utils:SetIfMissing}{11.1}{X7A6BB3D084912F35}
\makelabel{utils:PrintOneItemPerLine}{11.2}{X86F322FC7DECE36F}
\makelabel{utils:PrintApplicableMethod}{11.3.1}{X78B7D1A982BE9866}
\makelabel{utils:ExponentOfPrime}{11.3.2}{X7C1AF2467FB55D79}
\makelabel{utils:OKtoReadFromUtils}{12}{X84AC9613842F014C}
utils-0.93/doc/chap4.txt 0000644 0001751 0001751 00000016704 15105376105 014533 0 ustar runner runner
[1X4 [33X[0;0YNumber-theoretic functions[133X[101X
[1X4.1 [33X[0;0YFunctions for integers[133X[101X
[1X4.1-1 AllSmoothIntegers[101X
[33X[1;0Y[29X[2XAllSmoothIntegers[102X( [3Xmaxp[103X, [3Xmaxn[103X ) [32X function[133X
[33X[1;0Y[29X[2XAllSmoothIntegers[102X( [3XL[103X, [3Xmaxp[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThe function [10XAllSmoothIntegers([3Xmaxp[103X[10X,[3Xmaxn[103X[10X)[110X returns the list of all positive
integers less than or equal to [3Xmaxn[103X whose prime factors are all in the list
[22XL = {p ~|~ p leqslant maxp, p~mboxprime }[122X.[133X
[33X[0;0YIn the alternative form, when [22XL[122X is a list of primes, the function returns
the list of all positive integers whose prime factors lie in [22XL[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XAllSmoothIntegers( 3, 1000 );[127X[104X
[4X[28X[ 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 54, 64, 72, 81, 96, [128X[104X
[4X[28X 108, 128, 144, 162, 192, 216, 243, 256, 288, 324, 384, 432, 486, 512, 576, [128X[104X
[4X[28X 648, 729, 768, 864, 972 ][128X[104X
[4X[25Xgap>[125X [27XAllSmoothIntegers( [5,11,17], 1000 );[127X[104X
[4X[28X[ 1, 5, 11, 17, 25, 55, 85, 121, 125, 187, 275, 289, 425, 605, 625, 935 ][128X[104X
[4X[25Xgap>[125X [27XLength( last );[127X[104X
[4X[28X16[128X[104X
[4X[25Xgap>[125X [27XList( [3..20], n -> Length( AllSmoothIntegers( [5,11,17], 10^n ) ) );[127X[104X
[4X[28X[ 16, 29, 50, 78, 114, 155, 212, 282, 359, 452, 565, 691, 831, 992, 1173, [128X[104X
[4X[28X 1374, 1595, 1843 ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X4.1-2 AllProducts[101X
[33X[1;0Y[29X[2XAllProducts[102X( [3XL[103X, [3Xk[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThe command [10XAllProducts([3XL[103X[10X,[3Xk[103X[10X)[110X returns the list of all products of [3Xk[103X entries
of the list [3XL[103X. Note that every ordering of the entries is used so that, in
the commuting case, there are bound to be repetitions.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XAllProducts([1..4],3); [127X[104X
[4X[28X[ 1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16, 2, 4, 6, 8, 4, 8, 12, [128X[104X
[4X[28X 16, 6, 12, 18, 24, 8, 16, 24, 32, 3, 6, 9, 12, 6, 12, 18, 24, 9, 18, 27, [128X[104X
[4X[28X 36, 12, 24, 36, 48, 4, 8, 12, 16, 8, 16, 24, 32, 12, 24, 36, 48, 16, 32, [128X[104X
[4X[28X 48, 64 ][128X[104X
[4X[25Xgap>[125X [27XSet(last); [127X[104X
[4X[28X[ 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 64 ][128X[104X
[4X[25Xgap>[125X [27XAllProducts( [(1,2,3),(2,3,4)], 2 );[127X[104X
[4X[28X[ (2,4,3), (1,2)(3,4), (1,3)(2,4), (1,3,2) ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X4.1-3 RestrictedPartitionsWithoutRepetitions[101X
[33X[1;0Y[29X[2XRestrictedPartitionsWithoutRepetitions[102X( [3Xn[103X, [3XS[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YFor a positive integer [3Xn[103X and a set of positive integers [3XS[103X, this function
returns the list of partitions of [3Xn[103X into distinct elements of [3XS[103X. Unlike
[10XRestrictedPartitions[110X, no repetitions are allowed.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XRestrictedPartitions( 20, [4..10] );[127X[104X
[4X[28X[ [ 4, 4, 4, 4, 4 ], [ 5, 5, 5, 5 ], [ 6, 5, 5, 4 ], [ 6, 6, 4, 4 ], [128X[104X
[4X[28X [ 7, 5, 4, 4 ], [ 7, 7, 6 ], [ 8, 4, 4, 4 ], [ 8, 6, 6 ], [ 8, 7, 5 ], [128X[104X
[4X[28X [ 8, 8, 4 ], [ 9, 6, 5 ], [ 9, 7, 4 ], [ 10, 5, 5 ], [ 10, 6, 4 ], [128X[104X
[4X[28X [ 10, 10 ] ][128X[104X
[4X[25Xgap>[125X [27XRestrictedPartitionsWithoutRepetitions( 20, [4..10] );[127X[104X
[4X[28X[ [ 10, 6, 4 ], [ 9, 7, 4 ], [ 9, 6, 5 ], [ 8, 7, 5 ] ][128X[104X
[4X[25Xgap>[125X [27XRestrictedPartitionsWithoutRepetitions( 10^2, List([1..10], n->n^2 ) );[127X[104X
[4X[28X[ [ 100 ], [ 64, 36 ], [ 49, 25, 16, 9, 1 ] ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X4.1-4 NextProbablyPrimeInt[101X
[33X[1;0Y[29X[2XNextProbablyPrimeInt[102X( [3Xn[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThe function [10XNextProbablyPrimeInt([3Xn[103X[10X)[110X does the same as [10XNextPrimeInt([3Xn[103X[10X)[110X except
that for reasons of performance it tests numbers only for
[10XIsProbablyPrimeInt([3Xn[103X[10X)[110X instead of [10XIsPrimeInt([3Xn[103X[10X)[110X. For large [3Xn[103X, this function
is much faster than [10XNextPrimeInt([3Xn[103X[10X)[110X[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xn := 2^251;[127X[104X
[4X[28X3618502788666131106986593281521497120414687020801267626233049500247285301248[128X[104X
[4X[25Xgap>[125X [27XNextProbablyPrimeInt( n );[127X[104X
[4X[28X3618502788666131106986593281521497120414687020801267626233049500247285301313[128X[104X
[4X[25Xgap>[125X [27Xtime; [127X[104X
[4X[28X1[128X[104X
[4X[25Xgap>[125X [27XNextPrimeInt( n ); [127X[104X
[4X[28X3618502788666131106986593281521497120414687020801267626233049500247285301313[128X[104X
[4X[25Xgap>[125X [27Xtime; [127X[104X
[4X[28X213[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X4.1-5 PrimeNumbersIterator[101X
[33X[1;0Y[29X[2XPrimeNumbersIterator[102X( [[3Xchunksize[103X] ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThis function returns an iterator which runs over the prime numbers n
ascending order; it takes an optional argument [10Xchunksize[110X which specifies the
length of the interval which is sieved in one go (the default is [22X10^7[122X), and
which can be used to balance runtime vs. memory consumption. It is assumed
that [10Xchunksize[110X is larger than any gap between two consecutive primes within
the range one intends to run the iterator over.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xiter := PrimeNumbersIterator();;[127X[104X
[4X[25Xgap>[125X [27Xfor i in [1..100] do p := NextIterator(iter); od;[127X[104X
[4X[25Xgap>[125X [27Xp;[127X[104X
[4X[28X541[128X[104X
[4X[25Xgap>[125X [27Xsum := 0;;[127X[104X
[4X[25Xgap>[125X [27X## "prime number race" 1 vs. 3 mod 4[127X[104X
[4X[25Xgap>[125X [27Xfor p in PrimeNumbersIterator() do [127X[104X
[4X[25X>[125X [27X if p <> 2 then sum := sum + E(4)^(p-1); fi;[127X[104X
[4X[25X>[125X [27X if sum > 0 then break; fi;[127X[104X
[4X[25X>[125X [27X od;[127X[104X
[4X[25Xgap>[125X [27Xp;[127X[104X
[4X[28X26861[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
utils-0.93/doc/chap3.html 0000644 0001751 0001751 00000040234 15105376105 014652 0 ustar runner runner
GAP (Utils) - Chapter 3: Lists, Sets and Strings
This function has been transferred from package RCWA.
SearchCycle is a tool to find likely cycles in lists. What, precisely, a cycle is, is deliberately fuzzy here, and may possibly even change. The idea is that the beginning of the list may be anything, following that the same pattern needs to be repeated several times in order to be recognized as a cycle.
This function has been transferred from package ResClasses.
It returns a random unordered k-tuple of distinct elements of a set S.
gap>## "6 aus 49" is a common lottery in Germanygap>RandomCombination( [1..49], 6 );
[ 2, 16, 24, 26, 37, 47 ]
3.2 Distinct and Common Representatives
3.2-1 DistinctRepresentatives
‣ DistinctRepresentatives( list )
( operation )
‣ CommonRepresentatives( list )
( operation )
‣ CommonTransversal( grp, subgrp )
( operation )
‣ IsCommonTransversal( grp, subgrp, list )
( operation )
These operations have been transferred from package XMod.
They deal with lists of subsets of [1 ... n] and construct systems of distinct and common representatives using simple, non-recursive, combinatorial algorithms.
When L is a set of n subsets of [1 ... n] and the Hall condition is satisfied (the union of any k subsets has at least k elements), a set of DistinctRepresentatives exists.
When J,K are both lists of n sets, the operation CommonRepresentatives returns two lists: the set of representatives, and a permutation of the subsets of the second list.
The operation CommonTransversal may be used to provide a common transversal for the sets of left and right cosets of a subgroup H of a group G, although a greedy algorithm is usually quicker.
This function has been transferred from package RCWA.
This function converts the GAP logfile filename to HTML. It appears that the logfile should be in your current directory. The extension of the input file must be *.log. The name of the output file is the same as the one of the input file except that the extension *.log is replaced by *.html. There is a sample CSS file in utils/doc/gaplog.css, which you can adjust to your taste.
The function ConvertToMagmaInputString( obj [, str] ) attempts to output a string s which can be read into Magma[BCP97] so as to produce the same group in that computer algebra system. In the second form the user specifies the name of the resulting object, so that the output string has the form "str := ...".
When obj is a permutation group, the operation PermGroupToMagmaFormat(obj) is called. This function has been taken from other.gi in the main library where it was called MagmaInputString.
When obj is a pc-group, the operation PcGroupToMagmaFormat(obj) is called. This function was private code of Max Horn.
When obj is a matrix group over a finite field, the operation MatrixGroupToMagmaFormat(obj) is called. This function is a modification of private code of Frank LĂĽbeck.
Hopefully code for other types of group will be added in due course.
These functions should be considered experimental, and more testing is desirable.
The Download operation has been written by Thomas Breuer, incorporating a number of suggestions from Max Horn, for version 0.77 of Utils. It implements downloading a file from within GAP. It can use the IO or curlInterface packages, or wget or curl, if installed, and it can be extended with other download methods quite easily. It is envisaged that, once other packages have started to use it, and any problems have been addressed, that the functions will be transferred to the main GAP library.
9.1 Functions for downloading files from the web
9.1-1 Download
‣ Download( url[, opt] )
( function )
This function downloads the file with the web address url, which must be a string.
The result is a record which has at least the component success, with value true if the download was successful and false otherwise. In the former case, the component result is bound, whose value is a string that contains the contents of the downloaded file. In the latter case, the component error is bound, whose value is a string that describes the problem.
The function calls the methods stored in the global list Download_Methods until one of them is successful. Currently there are methods based on the GAP functions DownloadURL (curl: DownloadURL) and SingleHTTPRequest (IO: SingleHTTPRequest), and methods based on the external programs wget and curl.
An optional record opt can be given. The following components are supported.
maxTime
If this component is bound then its value must be a nonnegative integer n, meaning that the function gives up after n seconds.
A zero value of n means that no timeout is set, the method will never give up in this case.
The default for n is given by the value of the user preference DownloadMaxTime (see 9.1-3).
target
If this component is bound then its value must be a string that is a local filename, and the function writes the downloaded contents to this file; the returned record does not have a result component in this case.
verifyCert
If this component is bound and has the value false then those download methods that are based on curl or wget will omit the check of the server's certificate.
The same effect is achieved for all Download calls by setting the user preference DownloadVerifyCertificate (see 9.1-2) to false and omitting the verifyCert component from opt.
The value true (the default) means that the server's certificate is checked in calls of Download (9.1-1), such that nothing gets downloaded if the certificate is invalid.
If the value is false then download methods are supposed to omit the check of the server's certificate (this may not be supported by all download methods).
One can set the value of the preference to be val via SetUserPreference (Reference: SetUserPreference), by calling SetUserPreference( "utils", "DownloadVerifyCertificate", val ), and access the current value via UserPreference (Reference: UserPreference), by calling UserPreference( "utils", "DownloadVerifyCertificate" ).
We recommend leaving this preference at its default value true. Sometimes it can be necessary to change it, e.g. to work around issues with old operating systems which may not be able to correctly verify new certificates. In general it is better to update such a system, but if that is not an option, then disabling certificate checks may be a good last resort.
9.1-3 User preference DownloadMaxTime
The value 0 (the default) means that no timeout is set in calls of Download (9.1-1). If the value is a positive integer n then those download methods that support a timeout will give up after n seconds.
One can set the value of the preference to be val via SetUserPreference (Reference: SetUserPreference), by calling SetUserPreference( "utils", "DownloadMaxTime", val ), and access the current value via UserPreference (Reference: UserPreference), by calling UserPreference( "utils", "DownloadMaxTime" ).
utils-0.93/doc/template.xml 0000644 0001751 0001751 00000001744 15105376105 015326 0 ustar runner runner
Number-theoretic functionsFunctions for integers
These functions are in the process of being transferred from package &Home;.
They
utils-0.93/doc/chooser.html 0000644 0001751 0001751 00000007456 15105376105 015327 0 ustar runner runner
GAPDoc Style Chooser
utils-0.93/doc/lists.xml 0000644 0001751 0001751 00000016465 15105376105 014657 0 ustar runner runner
Lists, Sets and StringsFunctions for lists
This function has been transferred from package &ResClasses;.
It takes a list L of length n and outputs
the list of length n-1 containing all the differences
L[i]-L[i-1].
List( [1..12], n->n^3 );
[ 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728 ]
gap> DifferencesList( last );
[ 7, 19, 37, 61, 91, 127, 169, 217, 271, 331, 397 ]
gap> DifferencesList( last );
[ 12, 18, 24, 30, 36, 42, 48, 54, 60, 66 ]
gap> DifferencesList( last );
[ 6, 6, 6, 6, 6, 6, 6, 6, 6 ]
]]>
These functions have been transferred from package &ResClasses;.
They take a list L of length n and output the quotients
L[i]/L[i-1] of consecutive entries in L.
An error is returned if an entry is zero.
List( [0..10], n -> Factorial(n) );
[ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ]
gap> QuotientsList( last );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
gap> L := [ 1, 3, 5, -1, -3, -5 ];;
gap> QuotientsList( L );
[ 3, 5/3, -1/5, 3, 5/3 ]
gap> FloatQuotientsList( L );
[ 3., 1.66667, -0.2, 3., 1.66667 ]
gap> QuotientsList( [ 2, 1, 0, -1, -2 ] );
[ 1/2, 0, fail, 2 ]
gap> FloatQuotientsList( [1..10] );
[ 2., 1.5, 1.33333, 1.25, 1.2, 1.16667, 1.14286, 1.125, 1.11111 ]
gap> Product( last );
10.
]]>
This function has been transferred from package &RCWA;.
SearchCycle is a tool to find likely cycles in lists.
What, precisely, a cycle is, is deliberately fuzzy here,
and may possibly even change.
The idea is that the beginning of the list may be anything,
following that the same pattern needs to be repeated several times
in order to be recognized as a cycle.
L := [1..20];; L[1]:=13;;
gap> for i in [1..19] do
> if IsOddInt(L[i]) then L[i+1]:=3*L[i]+1; else L[i+1]:=L[i]/2; fi;
> od;
gap> L;
[ 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4 ]
gap> SearchCycle( L );
[ 1, 4, 2 ]
gap> n := 1;; L := [n];;
gap> for i in [1..100] do n:=(n^2+1) mod 1093; Add(L,n); od;
gap> L;
[ 1, 2, 5, 26, 677, 363, 610, 481, 739, 715, 795, 272, 754, 157, 604, 848,
1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271,
211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521,
378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272,
754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604,
848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004,
271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004 ]
gap> C := SearchCycle( L );
[ 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754 ]
gap> P := Positions( L, 157 );
[ 14, 26, 38, 50, 62, 74, 86, 98 ]
gap> Length( C ); DifferencesList( P );
12
[ 12, 12, 12, 12, 12, 12, 12 ]
]]>
This function has been transferred from package &ResClasses;.
It returns a random unordered k-tuple of distinct elements
of a set S.
## "6 aus 49" is a common lottery in Germany
gap> RandomCombination( [1..49], 6 );
[ 2, 16, 24, 26, 37, 47 ]
]]>
Distinct and Common Representativesdistinct and common representatives
These operations have been transferred from package &XMod;.
They deal with lists of subsets of [1 \ldots n]
and construct systems of distinct and common representatives using
simple, non-recursive, combinatorial algorithms.
When L is a set of n subsets of [1 \ldots n]
and the Hall condition is satisfied
(the union of any k subsets has at least k elements),
a set of DistinctRepresentatives exists.
When J,K are both lists of n sets,
the operation CommonRepresentatives returns two lists:
the set of representatives,
and a permutation of the subsets of the second list.
The operation CommonTransversal may be used to provide a
common transversal for the sets of left and right cosets
of a subgroup H of a group G,
although a greedy algorithm is usually quicker.
J := [ [1,2,3], [3,4], [3,4], [1,2,4] ];;
gap> DistinctRepresentatives( J );
[ 1, 3, 4, 2 ]
gap> K := [ [3,4], [1,2], [2,3], [2,3,4] ];;
gap> CommonRepresentatives( J, K );
[ [ 3, 3, 3, 1 ], [ 1, 3, 4, 2 ] ]
gap> d16 := DihedralGroup( IsPermGroup, 16 );
Group([ (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) ])
gap> SetName( d16, "d16" );
gap> c4 := Subgroup( d16, [ d16.1^2 ] );
Group([ (1,3,5,7)(2,4,6,8) ])
gap> SetName( c4, "c4" );
gap> RightCosets( d16, c4 );
[ RightCoset(c4,()), RightCoset(c4,(2,8)(3,7)(4,6)), RightCoset(c4,(1,8,7,6,5,
4,3,2)), RightCoset(c4,(1,8)(2,7)(3,6)(4,5)) ]
gap> trans := CommonTransversal( d16, c4 );
[ (), (2,8)(3,7)(4,6), (1,2,3,4,5,6,7,8), (1,2)(3,8)(4,7)(5,6) ]
gap> IsCommonTransversal( d16, c4, trans );
true
]]>
Functions for strings
This function has been transferred from package &ResClasses;.
The result of BlankFreeString( obj );
is a composite of the functions String( obj ) and
RemoveCharacters( obj, " " );.
gens := GeneratorsOfGroup( DihedralGroup(12) );
[ f1, f2, f3 ]
gap> String( gens );
"[ f1, f2, f3 ]"
gap> BlankFreeString( gens );
"[f1,f2,f3]"
]]>
utils-0.93/doc/download.xml 0000644 0001751 0001751 00000013567 15105376105 015330 0 ustar runner runner
Web Downloads
The Download operation has been written by Thomas Breuer,
incorporating a number of suggestions from Max Horn,
for version 0.77 of Utils.
It implements downloading a file from within &GAP;.
It can use the IO or curlInterface
packages, or wget or curl, if installed,
and it can be extended with other download methods quite easily.
It is envisaged that, once other packages have started to use it,
and any problems have been addressed, that the functions will be transferred
to the main &GAP; library.
Functions for downloading files from the web
This function downloads the file with the web address url,
which must be a string.
The result is a record which has at least the component success,
with value true if the download was successful and false
otherwise.
In the former case, the component result is bound,
whose value is a string that contains the contents of the downloaded file.
In the latter case, the component error is bound,
whose value is a string that describes the problem.
The function calls the methods stored in the global list
Download_Methods until one of them is successful.
Currently there are methods based on the &GAP; functions
and
,
and methods based on the external programs wget and curl.
An optional record opt can be given.
The following components are supported.
maxTime
If this component is bound then its value must be a nonnegative integer
n, meaning that the function gives up after n seconds.
A zero value of n means that no timeout is set, the method will
never give up in this case.
The default for n is given by the value of the user preference
DownloadMaxTime (see ).
target
If this component is bound then its value must be a string
that is a local filename,
and the function writes the downloaded contents to this file;
the returned record does not have a result component in this case.
verifyCert
If this component is bound and has the value false
then those download methods that are based on curl or wget
will omit the check of the server's certificate.
The same effect is achieved for all calls
by setting the user preference DownloadVerifyCertificate
(see ) to false
and omitting the verifyCert component from opt.
url:= "https://www.gap-system.org/index.html";;
gap> res1:= Download( url );;
gap> res1.success;
true
gap> IsBound( res1.result ) and IsString( res1.result );
true
gap> res2:= Download( Concatenation( url, "xxx" ) );;
gap> res2.success;
false
gap> IsBound( res2.error ) and IsString( res2.error );
true
]]>
User preference DownloadVerifyCertificateDownloadVerifyCertificate
The value true (the default) means that the server's certificate
is checked in calls of ,
such that nothing gets downloaded if the certificate is invalid.
If the value is false then download methods are supposed to omit
the check of the server's certificate (this may not be supported by all
download methods).
One can set the value of the preference to be val via
, by calling
SetUserPreference( "utils", "DownloadVerifyCertificate", val ),
and access the current value via
, by calling
UserPreference( "utils", "DownloadVerifyCertificate" ).
We recommend leaving this preference at its default value true.
Sometimes it can be necessary to change it, e.g. to work around issues
with old operating systems which may not be able to correctly verify new
certificates. In general it is better to update such a system, but if that is
not an option, then disabling certificate checks may be a good last resort.
User preference DownloadMaxTimeDownloadMaxTime
The value 0 (the default) means that no timeout is set
in calls of .
If the value is a positive integer n then those download methods that
support a timeout will give up after n seconds.
One can set the value of the preference to be val via
, by calling
SetUserPreference( "utils", "DownloadMaxTime", val ),
and access the current value via
, by calling
UserPreference( "utils", "DownloadMaxTime" ).
utils-0.93/doc/number.xml 0000644 0001751 0001751 00000013326 15105376105 015002 0 ustar runner runner
Number-theoretic functionsFunctions for integers
This function has been transferred from package &RCWA;.
smooth integer
The function AllSmoothIntegers(maxp,maxn)
returns the list of all positive integers less than or equal to maxn
whose prime factors are all in the list
L = \{p ~|~ p \leqslant maxp, p~\mbox{prime} \}.
In the alternative form, when L is a list of primes,
the function returns the list of all positive integers
whose prime factors lie in L.
AllSmoothIntegers( 3, 1000 );
[ 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 54, 64, 72, 81, 96,
108, 128, 144, 162, 192, 216, 243, 256, 288, 324, 384, 432, 486, 512, 576,
648, 729, 768, 864, 972 ]
gap> AllSmoothIntegers( [5,11,17], 1000 );
[ 1, 5, 11, 17, 25, 55, 85, 121, 125, 187, 275, 289, 425, 605, 625, 935 ]
gap> Length( last );
16
gap> List( [3..20], n -> Length( AllSmoothIntegers( [5,11,17], 10^n ) ) );
[ 16, 29, 50, 78, 114, 155, 212, 282, 359, 452, 565, 691, 831, 992, 1173,
1374, 1595, 1843 ]
]]>
This function has been transferred from package &RCWA;.
The command AllProducts(L,k) returns the list of
all products of k entries of the list L.
Note that every ordering of the entries is used so that, in the commuting case,
there are bound to be repetitions.
AllProducts([1..4],3);
[ 1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16, 2, 4, 6, 8, 4, 8, 12,
16, 6, 12, 18, 24, 8, 16, 24, 32, 3, 6, 9, 12, 6, 12, 18, 24, 9, 18, 27,
36, 12, 24, 36, 48, 4, 8, 12, 16, 8, 16, 24, 32, 12, 24, 36, 48, 16, 32,
48, 64 ]
gap> Set(last);
[ 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 64 ]
gap> AllProducts( [(1,2,3),(2,3,4)], 2 );
[ (2,4,3), (1,2)(3,4), (1,3)(2,4), (1,3,2) ]
]]>
This function has been transferred from package &RCWA;.
For a positive integer n and a set of positive integers S,
this function returns the list of partitions of n
into distinct elements of S.
Unlike RestrictedPartitions, no repetitions are allowed.
RestrictedPartitions( 20, [4..10] );
[ [ 4, 4, 4, 4, 4 ], [ 5, 5, 5, 5 ], [ 6, 5, 5, 4 ], [ 6, 6, 4, 4 ],
[ 7, 5, 4, 4 ], [ 7, 7, 6 ], [ 8, 4, 4, 4 ], [ 8, 6, 6 ], [ 8, 7, 5 ],
[ 8, 8, 4 ], [ 9, 6, 5 ], [ 9, 7, 4 ], [ 10, 5, 5 ], [ 10, 6, 4 ],
[ 10, 10 ] ]
gap> RestrictedPartitionsWithoutRepetitions( 20, [4..10] );
[ [ 10, 6, 4 ], [ 9, 7, 4 ], [ 9, 6, 5 ], [ 8, 7, 5 ] ]
gap> RestrictedPartitionsWithoutRepetitions( 10^2, List([1..10], n->n^2 ) );
[ [ 100 ], [ 64, 36 ], [ 49, 25, 16, 9, 1 ] ]
]]>
This function has been transferred from package &RCWA;.
The function NextProbablyPrimeInt(n)
does the same as NextPrimeInt(n)
except that for reasons of performance it tests numbers only for
IsProbablyPrimeInt(n) instead of IsPrimeInt(n).
For large n, this function is much faster than
NextPrimeInt(n)
n := 2^251;
3618502788666131106986593281521497120414687020801267626233049500247285301248
gap> NextProbablyPrimeInt( n );
3618502788666131106986593281521497120414687020801267626233049500247285301313
gap> time;
1
gap> NextPrimeInt( n );
3618502788666131106986593281521497120414687020801267626233049500247285301313
gap> time;
213
]]>
This function has been transferred from package &RCWA;.
This function returns an iterator which runs over the prime numbers
n ascending order; it takes an optional argument chunksize
which specifies the length of the interval which is sieved in one go
(the default is 10^7),
and which can be used to balance runtime vs. memory consumption.
It is assumed that chunksize is larger than any gap between two
consecutive primes within the range one intends to run the iterator over.
iter := PrimeNumbersIterator();;
gap> for i in [1..100] do p := NextIterator(iter); od;
gap> p;
541
gap> sum := 0;;
gap> ## "prime number race" 1 vs. 3 mod 4
gap> for p in PrimeNumbersIterator() do
> if p <> 2 then sum := sum + E(4)^(p-1); fi;
> if sum > 0 then break; fi;
> od;
gap> p;
26861
]]>
utils-0.93/doc/chapBib.html 0000644 0001751 0001751 00000013540 15105376105 015204 0 ustar runner runner
GAP (Utils) - References
[BCP97] Bosma, W., Cannon, J. and Playoust, C.,
The Magma algebra system. {I}. The user language,
J. Symbolic Comput.,
24 (3-4)
(1997),
235--265 pages
(
Computational algebra and number theory (London, 1993)}
https://doi.org/10.1006/jsco.1996.0125).
[GH16] Gutsche, S. and Horn, M.,
AutoDoc - Generate documentation from GAP source code (Version 2016.12.04)
(2016)
(
GAP package, https://github.com/gap-packages/AutoDoc).
[WAOU17] Wensley, C. D., Alp, M., Odabas, A. and Uslu, E. O.,
XMod - Crossed Modules and Cat1-groups in GAP (Version 2.64)
(2017)
(
GAP package, https://github.com/gap-packages/xmod).
The functions described here print lists or objects with an iterator with one item per line, either the whole list/iterator or certain subsets:
by giving a list of positions of items to be printed, or
by specifying a first item and then a regular step.
2.1-1 PrintSelection
‣ PrintSelection( obj, list )
( function )
‣ PrintSelection( obj, first, step[, last] )
( function )
This function, given three (or four) parameters, calls operations PrintSelectionFromList or PrintSelectionFromIterator which prints the first item specified, and then the item at every step. The fourth parameter is essential when the object being printed is infinite.
Alternatively, given two parameters, with the second parameter a list L of positive integers, only the items at positions in L are printed.
The Utils package provides a space for utility functions in a variety of GAP packages to be collected together into a single package. In this way it is hoped that they will become more visible to package authors.
Any package author who transfers a function to Utils will become an author of Utils.
If deemed appropriate, functions may also be transferred from the main library.
The Utils package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
Acknowledgements
This documentation was prepared using the GAPDoc[LN17] and AutoDoc[GH16] packages.
The procedure used to produce new releases uses the package GitHubPagesForGAP[Hor17] and the package ReleaseTools.
The Utils package provides a space for utility functions in a variety of GAP packages to be collected together into a single package. In this way it is hoped that they will become more visible to package authors.
Any package author who transfers a function to Utils will become an author of Utils.
If deemed appropriate, functions may also be transferred from the main library.
The Utils package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
Acknowledgements
This documentation was prepared using the GAPDoc[LN17] and AutoDoc[GH16] packages.
The procedure used to produce new releases uses the package GitHubPagesForGAP[Hor17] and the package ReleaseTools.
utils-0.93/doc/chapBib.txt 0000644 0001751 0001751 00000003411 15105376105 015053 0 ustar runner runner
[1XReferences[101X
[[20XBCP97[120X] [16XBosma, W., Cannon, J. and Playoust, C.[116X, [17XThe Magma algebra system.
{I}. The user language[117X, [18XJ. Symbolic Comput.[118X, [19X24[119X, 3-4 (1997), 235--265 pages,
( Computational algebra and number theory (London, 1993)}
https://doi.org/10.1006/jsco.1996.0125 ).
[[20XGH16[120X] [16XGutsche, S. and Horn, M.[116X, [17XAutoDoc - Generate documentation from GAP
source code (Version 2016.12.04)[117X (2016), ( GAP package,
https://github.com/gap-packages/AutoDoc ).
[[20XHor17[120X] [16XHorn, M.[116X, [17XGitHubPagesForGAP - Template for easily using GitHub Pages
within GAP packages (Version 0.2)[117X (2017), ( GAP package,
https://gap-system.github.io/GitHubPagesForGAP/ ).
[[20XKoh17a[120X] [16XKohl, S.[116X, [17XRCWA - Residue-Class-Wise Affine Groups (Version 4.5.1)[117X
(2017), ( GAP package, https://stefan-kohl.github.io/rcwa.html ).
[[20XKoh17b[120X] [16XKohl, S.[116X, [17XResClasses - Set-Theoretic Computations with Residue
Classes (Version 4.6.0)[117X (2017), ( GAP package,
https://stefan-kohl.github.io/resclasses.html ).
[[20XLN17[120X] [16XLübeck, F. and Neunhöffer, M.[116X, [17XGAPDoc (Version 1.6)[117X, RWTH Aachen
(2017), ( GAP package,
https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc/index.html ).
[[20XWAOU17[120X] [16XWensley, C. D., Alp, M., Odabas, A. and Uslu, E. O.[116X, [17XXMod - Crossed
Modules and Cat1-groups in GAP (Version 2.64)[117X (2017), ( GAP package,
https://github.com/gap-packages/xmod ).
[32X
utils-0.93/doc/groups.xml 0000644 0001751 0001751 00000041031 15105376105 015023 0 ustar runner runner
Groups and homomorphismsFunctions for groups
This method has been transferred from package &ResClasses;.
It provides a method for Comm when the argument is a list
(enclosed in square brackets), and calls the function LeftNormedComm.
Comm( [ (1,2), (2,3) ] );
(1,2,3)
gap> Comm( [(1,2),(2,3),(3,4),(4,5),(5,6)] );
(1,5,6)
gap> Comm(Comm(Comm(Comm((1,2),(2,3)),(3,4)),(4,5)),(5,6)); ## the same
(1,5,6)
]]>
This function has been transferred from package &ResClasses;.
It tests whether two elements in a group commute.
D12 := DihedralGroup( 12 );
gap> SetName( D12, "D12" );
gap> a := D12.1;; b := D12.2;;
gap> IsCommuting( a, b );
false
]]>
This function has been transferred from package &RCWA;.
The operation ListOfPowers(g,exp) returns the list
[g,g^2,...,g^{exp}] of powers of the element g.
ListOfPowers( 2, 20 );
[ 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384,
32768, 65536, 131072, 262144, 524288, 1048576 ]
gap> ListOfPowers( (1,2,3)(4,5), 12 );
[ (1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5), (),
(1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5), () ]
gap> ListOfPowers( D12.2, 6 );
[ f2, f3, f2*f3, f3^2, f2*f3^2, of ... ]
]]>
This function has been transferred from package &RCWA;.
This operation returns a list containing the generators of G
followed by the inverses of these generators.
GeneratorsAndInverses( D12 );
[ f1, f2, f3, f1, f2*f3^2, f3^2 ]
gap> GeneratorsAndInverses( SymmetricGroup(5) );
[ (1,2,3,4,5), (1,2), (1,5,4,3,2), (1,2) ]
]]>
These three functions have been transferred from package &ResClasses;.
Fitting series
The upper and lower Fitting series and the Fitting length of a solvable
group are described here:
https://en.wikipedia.org/wiki/Fitting_length.
UpperFittingSeries( D12 ); LowerFittingSeries( D12 );
[ Group([ ]), Group([ f3, f2*f3 ]), Group([ f1, f3, f2*f3 ]) ]
[ D12, Group([ f3 ]), Group([ ]) ]
gap> FittingLength( D12 );
2
gap> S4 := SymmetricGroup( 4 );;
gap> UpperFittingSeries( S4 );
[ Group(()), Group([ (1,2)(3,4), (1,4)(2,3) ]), Group([ (1,2)(3,4), (1,4)
(2,3), (2,4,3) ]), Group([ (3,4), (2,3,4), (1,2)(3,4) ]) ]
gap> List( last, StructureDescription );
[ "1", "C2 x C2", "A4", "S4" ]
gap> LowerFittingSeries( S4 );
[ Sym( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), Group([ (1,4)(2,3), (1,3)
(2,4) ]), Group(()) ]
gap> List( last, StructureDescription );
[ "S4", "A4", "C2 x C2", "1" ]
gap> FittingLength( S4);
3
]]>
Left Cosets for Groups
Since &GAP; uses right actions by default, the library contains
the operation RightCoset(U,g) for constructing the right coset
Ug of a subgroup U \leq G and an element g \in G.
It has been noted in the reference manual that, by inverting all the elements
in Ug, the left coset g^{-1}U is obtained.
Just for the sake of completeness, from August 2022 this package provides
the operation LeftCoset(g,U) for constructing the left coset gU.
Users are strongly recommended to continue to use RightCoset
for all serious calculations, since left cosets have a much simpler
implementation and do not behave exactly like right cosets.
The methods for left cosets which are provided generally work
by converting gU to Ug^{-1};
applying the equivalent method for right cosets;
and, if necessary, converting back again to left cosets.
G acts on left cosets by OnLeftInverse:
(gU)^{g_0} = g_0^{-1}*(gU) = (g_0^{-1}g)U.
a4 := Group( (1,2,3), (2,3,4) );; SetName( a4, "a4" );
gap> k4 := Group( (1,2)(3,4), (1,3)(2,4) );; SetName( k4, "k4" );
gap> rc := RightCosets( a4, k4 );
[ RightCoset(k4,()), RightCoset(k4,(2,3,4)), RightCoset(k4,(2,4,3)) ]
gap> lc := LeftCosets( a4, k4 );
[ LeftCoset((),k4), LeftCoset((2,4,3),k4), LeftCoset((2,3,4),k4) ]
gap> AsSet( lc[2] );
[ (2,4,3), (1,2,3), (1,3,4), (1,4,2) ]
gap> LeftCoset( (1,4,2), k4 ) = lc[2];
true
gap> Representative( lc[2] );
(2,4,3)
gap> ActingDomain( lc[2] );
k4
gap> (1,4,3) in lc[3];
true
gap> (1,2,3)*lc[2] = lc[3];
true
gap> lc[2]^(1,3,2) = lc[3];
true
]]>
Inverse
The inverse of the left coset gU is the right coset Ug^{-1},
and conversely.
This is an abuse of the attribute Inverse, since the standard
requirement, that x*x^{-1} is an identity, does not hold.
Inverse( rc[3] ) = lc[3];
true
gap> Inverse( lc[2] ) = rc[2];
true
]]>
Functions for group homomorphisms
This function has been transferred from package &RCWA;.
It constructs a group homomorphism which maps
the generators of G to those of H.
Its intended use is when G is a free group,
and a warning is printed when this is not the case.
Note that anything may happen if the resulting map is not a homomorphism!
G := Group( (1,2,3), (3,4,5), (5,6,7), (7,8,9) );;
gap> phi := EpimorphismByGenerators( FreeGroup("a","b","c","d"), G );
[ a, b, c, d ] -> [ (1,2,3), (3,4,5), (5,6,7), (7,8,9) ]
gap> PreImagesRepresentativeNC( phi, (1,2,3,4,5,6,7,8,9) );
d*c*b*a
gap> a := G.1;; b := G.2;; c := G.3;; d := G.4;;
gap> d*c*b*a;
(1,2,3,4,5,6,7,8,9)
gap> ## note that it is easy to produce nonsense:
gap> epi := EpimorphismByGenerators( Group((1,2,3)), Group((8,9)) );
Warning: calling GroupHomomorphismByImagesNC without checks
[ (1,2,3) ] -> [ (8,9) ]
gap> IsGroupHomomorphism( epi );
true
gap> Image( epi, (1,2,3) );
()
gap> Image( epi, (1,3,2) );
(8,9)
]]>
If \phi_1 : G_1 \to H and \phi_2 : G_2 \to H
are two group homomorphisms with the same range, then their pullback
is the subgroup of G_1 \times G_2 consisting of those elements
(g_1,g_2) such that \phi_1 g_1 = \phi_2 g_2.
The attribute PullbackInfo of a pullback group P
is similar to DirectProductInfo for a direct product of groups.
Its value is a record with the following components:
directProduct
the direct product G_1 \times G_2, and
projections
a list with the two projections onto G_1 and G_2.
There are no embeddings in this record,
but it is possible to use the embeddings into the direct product,
see .
s4 := Group( (1,2),(2,3),(3,4) );;
gap> s3 := Group( (5,6),(6,7) );;
gap> c3 := Subgroup( s3, [ (5,6,7) ] );;
gap> f := GroupHomomorphismByImages( s4, s3,
> [(1,2),(2,3),(3,4)], [(5,6),(6,7),(5,6)] );;
gap> i := GroupHomomorphismByImages( c3, s3, [(5,6,7)], [(5,6,7)] );;
gap> Pfi := Pullback( f, i );
Group([ (2,3,4)(5,7,6), (1,2)(3,4) ])
gap> StructureDescription( Pfi );
"A4"
gap> info := PullbackInfo( Pfi );
rec( directProduct := Group([ (1,2), (2,3), (3,4), (5,6,7) ]),
projections := [ [ (2,3,4)(5,7,6), (1,2)(3,4) ] -> [ (2,3,4), (1,2)(3,4) ],
[ (2,3,4)(5,7,6), (1,2)(3,4) ] -> [ (5,7,6), () ] ] )
gap> g := (1,2,3)(5,6,7);;
gap> ImageElm( info!.projections[1], g );
(1,2,3)
gap> ImageElm( info!.projections[2], g );
(5,6,7)
gap> dp := info!.directProduct;;
gap> a := ImageElm( Embedding( dp, 1 ), (1,4,3) );;
gap> b := ImageElm( Embedding( dp, 2 ), (5,7,6) );;
gap> a*b in Pfi;
true
]]>
This function was added by Thomas Breuer,
following discussions with Hongyi Zhao
(see https://github.com/gap-packages/hap/issues/73).
Let G1 and G2 be two groups,
Z1 be a central subgroup of G1,
and Phi be an isomorphism from Z1 to a central subgroup of
G2.
The central product defined by these arguments is the factor group of
the direct product of G1 and G2 by the central subgroup
\{ (z, (Phi(z))^{-1}) : z \in Z1 \}.
The attribute of a group G
that has been created by
is similar to for pullback groups.
Its value is a record with the following components.
projection
the epimorphism from the direct product of G1 and G2
to G, and
phi
the map Phi.
Note that one can access the direct product as the
value of the projection map,
and one can access G1 and G2 as the two embeddings of this
direct product, see .
g1 := DihedralGroup( 8 );
gap> c1 := Centre( g1 );
Group([ f3 ])
gap> cp1 := CentralProduct( g1, g1, c1, IdentityMapping( c1 ) );
Group([ f1, f2, f5, f3, f4, f5 ])
gap> IdGroup( cp1 ) = IdGroup( ExtraspecialGroup( 2^5, "+" ) );
true
gap> g2 := QuaternionGroup( 8 );
gap> c2 := Centre( g2 );
Group([ y2 ])
gap> cp2 := CentralProduct( g2, g2, c2, IdentityMapping( c2 ) );
Group([ f1, f2, f5, f3, f4, f5 ])
gap> IdGroup( cp2 ) = IdGroup( ExtraspecialGroup( 2^5, "+" ) );
true
gap> info2 := CentralProductInfo( cp2 );
rec( phi := IdentityMapping( Group([ y2 ]) ),
projection := [ f1, f2, f3, f4, f5, f6 ] -> [ f1, f2, f5, f3, f4, f5 ] )
gap> Source( Embedding( Source( info2.projection ), 1 ) ) = g2;
true
]]>
An endomorphism f : G \to G is idempotent if f^2=f.
It has an image R \leqslant G;
is the identity map when restricted to R;
and has a kernel N which has trivial intersection with R
and has size |G|/|R|.
The operation IdempotentEndomorphismsWithImage(genG,R)
returns a list of the images of the generating set genG
of a group G under the idempotent endomorphisms with image R.
The attribute IdempotentEndomorphismsData(G) returns a record
data with fields data.gens, a fixed generating set for G,
and data.images a list of the non-empty outputs of
IdempotentEndomorphismsWithImage(genG,R)
obtained by iterating over all subgroups of G.
The operation IdempotentEndomorphisms(G) returns the list
of these mappings obtained using IdempotentEndomorphismsData(G).
The first of these is the zero map, the second is the identity.
gens := [ (1,2,3,4), (1,2)(3,4) ];;
gap> d8 := Group( gens );;
gap> SetName( d8, "d8" );
gap> c2 := Subgroup( d8, [ (2,4) ] );;
gap> IdempotentEndomorphismsWithImage( gens, c2 );
[ [ (), (2,4) ], [ (2,4), () ] ]
gap> IdempotentEndomorphismsData( d8 );
rec( gens := [ (1,2,3,4), (1,2)(3,4) ],
images := [ [ [ (), () ] ], [ [ (), (2,4) ], [ (2,4), () ] ],
[ [ (), (1,3) ], [ (1,3), () ] ],
[ [ (), (1,2)(3,4) ], [ (1,2)(3,4), (1,2)(3,4) ] ],
[ [ (), (1,4)(2,3) ], [ (1,4)(2,3), (1,4)(2,3) ] ],
[ [ (1,2,3,4), (1,2)(3,4) ] ] ] )
gap> List( last.images, L -> Length(L) );
[ 1, 2, 2, 2, 2, 1 ]
gap> IdempotentEndomorphisms( d8 );
[ [ (1,2,3,4), (1,2)(3,4) ] -> [ (), () ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (2,4) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (2,4), () ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,3) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,3), () ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,2)(3,4) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,2)(3,4), (1,2)(3,4) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,4)(2,3) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,4)(2,3), (1,4)(2,3) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,2,3,4), (1,2)(3,4) ] ]
]]>
The quaternion group q8 is an example of a group with a tail:
there is only one subgroup in the lattice which covers the identity subgroup.
The only idempotent isomorphisms of such groups are the identity mapping
and the zero mapping because the only pairs N,R are the whole group and the identity subgroup.
q8 := QuaternionGroup( 8 );;
gap> IdempotentEndomorphisms( q8 );
[ [ x, y ] -> [ of ..., of ... ], [ x, y ] -> [ x, y ] ]
]]>
Given group homomorphisms f_1 : G_1 \to G_2 and f_2 : H_1 \to H_2,
this operation return the product homomorphism
f_1 \times f_2 : G_1 \times G_2 \to H_1 \times H_2.
c4 := Group( (1,2,3,4) );;
gap> c2 := Group( (5,6) );;
gap> f1 := GroupHomomorphismByImages( c4, c2, [(1,2,3,4)], [(5,6)] );;
gap> c3 := Group( (1,2,3) );;
gap> c6 := Group( (1,2,3,4,5,6) );;
gap> f2 := GroupHomomorphismByImages( c3, c6, [(1,2,3)], [(1,3,5)(2,4,6)] );;
gap> c4c3 := DirectProduct( c4, c3 );
Group([ (1,2,3,4), (5,6,7) ])
gap> c2c6 := DirectProduct( c2, c6 );
Group([ (1,2), (3,4,5,6,7,8) ])
gap> f := DirectProductOfFunctions( c4c3, c2c6, f1, f2 );
[ (1,2,3,4), (5,6,7) ] -> [ (1,2), (3,5,7)(4,6,8) ]
gap> ImageElm( f, (1,4,3,2)(5,7,6) );
(1,2)(3,7,5)(4,8,6)
]]>
Let A_1,A_2 be groups of automorphism of groups G_1,G_2
respectively. The output of this function is a group A_1 \times A_2
of automorphisms of G_1 \times G_2.
c9 := Group( (1,2,3,4,5,6,7,8,9) );;
gap> ac9 := AutomorphismGroup( c9 );;
gap> q8 := QuaternionGroup( IsPermGroup, 8 );;
gap> aq8 := AutomorphismGroup( q8 );;
gap> A := DirectProductOfAutomorphismGroups( ac9, aq8 );
gap> genA := GeneratorsOfGroup( A );;
gap> G := Source( genA[1] );
Group([ (1,2,3,4,5,6,7,8,9), (10,14,12,16)(11,17,13,15), (10,11,12,13)
(14,15,16,17) ])
gap> a := genA[1]*genA[5];
[ (1,2,3,4,5,6,7,8,9), (10,14,12,16)(11,17,13,15), (10,11,12,13)(14,15,16,17)
] -> [ (1,3,5,7,9,2,4,6,8), (10,16,12,14)(11,15,13,17),
(10,11,12,13)(14,15,16,17) ]
gap> ImageElm( a, (1,9,8,7,6,5,4,3,2)(10,14,12,16)(11,17,13,15) );
(1,8,6,4,2,9,7,5,3)(10,16,12,14)(11,15,13,17)
]]>
utils-0.93/doc/chap11.html 0000644 0001751 0001751 00000017337 15105376105 014741 0 ustar runner runner
GAP (Utils) - Chapter 11: Obsolete functions
The file functions FindMatchingFiles and CreateDirIfMissing were copied from package AutoDoc where they are named AutoDoc_FindMatchingFiles and AutoDoc_CreateDirIfMissing.
The string function StringDotSuffix was also copied from package AutoDoc, where it is named AUTODOC_GetSuffix.
The function SetIfMissing was also transferred from package AutoDoc, where it is called AUTODOC_SetIfMissing. It writes into a record provided the position is not yet bound.
As from version 0.61, all these functions became obsolete in Utils, but continue to be defined in AutoDoc.
11.2 Functions for printing
The function PrintOneItemPerLine was used to prints lists vertically, rather than horizontally. Since a very similar result may be achieved using the GAP library functions Perform and Display, this function became obsolete in version 0.61.
The function PrintApplicableMethod, which was included in versions from 0.41 to 0.58, has been removed since it was considered superfluous. The example shows how to print out a function.
gap>ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 1, 1 );
#I Searching Method for IsCyclic with 1 arguments:
#I Total: 7 entries
#I Method 4: ``IsCyclic'' at /Applications/gap/gap4r9/lib/grp.gi:30 , value:
36
function( G ) ... end
gap>Print( last );
function ( G )
if Length( GeneratorsOfGroup( G ) ) = 1 then
return true;
else
TryNextMethod();
fi;
return;
end
gap>ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 0, 3 );
function( <1 unnamed arguments> ) ... end
gap>Print( last );
function ( <<arg-1>> )
<<compiled GAP code from GAPROOT/lib/oper1.g:578>>
end
11.3-2 ExponentOfPrime
The function ExponentOfPrime was originally transferred from package RCWA. The command ExponentOfPrime(n,p) returned the exponent of the prime p in the prime factorization of n.
Since the GAP function PValuation produces the same results, and does so more quickly, this function has been made obsolete.
utils-0.93/doc/times.css 0000644 0001751 0001751 00000000261 15105376105 014615 0 ustar runner runner /* times.css Frank LĂĽbeck */
/* Change default CSS to use Times font. */
body {
font-family: Times,Times New Roman,serif;
}
utils-0.93/doc/utils.tex 0000644 0001751 0001751 00000301512 15105376105 014647 0 ustar runner runner % generated by GAPDoc2LaTeX from XML source (Frank Luebeck)
\documentclass[a4paper,11pt]{report}
\usepackage[top=37mm,bottom=37mm,left=27mm,right=27mm]{geometry}
\sloppy
\pagestyle{myheadings}
\usepackage{amssymb}
\usepackage[utf8]{inputenc}
\usepackage{makeidx}
\makeindex
\usepackage{color}
\definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083}
\definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179}
\definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894}
\definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894}
\definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000}
\definecolor{Black}{rgb}{0.0,0.0,0.0}
\definecolor{linkColor}{rgb}{0.0,0.0,0.554}
\definecolor{citeColor}{rgb}{0.0,0.0,0.554}
\definecolor{fileColor}{rgb}{0.0,0.0,0.554}
\definecolor{urlColor}{rgb}{0.0,0.0,0.554}
\definecolor{promptColor}{rgb}{0.0,0.0,0.589}
\definecolor{brkpromptColor}{rgb}{0.589,0.0,0.0}
\definecolor{gapinputColor}{rgb}{0.589,0.0,0.0}
\definecolor{gapoutputColor}{rgb}{0.0,0.0,0.0}
%% for a long time these were red and blue by default,
%% now black, but keep variables to overwrite
\definecolor{FuncColor}{rgb}{0.0,0.0,0.0}
%% strange name because of pdflatex bug:
\definecolor{Chapter }{rgb}{0.0,0.0,0.0}
\definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}
\usepackage{fancyvrb}
\usepackage{mathptmx,helvet}
\usepackage[T1]{fontenc}
\usepackage{textcomp}
\usepackage[
pdftex=true,
bookmarks=true,
a4paper=true,
pdftitle={Written with GAPDoc},
pdfcreator={LaTeX with hyperref package / GAPDoc},
colorlinks=true,
backref=page,
breaklinks=true,
linkcolor=linkColor,
citecolor=citeColor,
filecolor=fileColor,
urlcolor=urlColor,
pdfpagemode={UseNone},
]{hyperref}
\newcommand{\maintitlesize}{\fontsize{50}{55}\selectfont}
% write page numbers to a .pnr log file for online help
\newwrite\pagenrlog
\immediate\openout\pagenrlog =\jobname.pnr
\immediate\write\pagenrlog{PAGENRS := [}
\newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}}
%% were never documented, give conflicts with some additional packages
\newcommand{\GAP}{\textsf{GAP}}
%% nicer description environments, allows long labels
\usepackage{enumitem}
\setdescription{style=nextline}
%% depth of toc
\setcounter{tocdepth}{1}
%% command for ColorPrompt style examples
\newcommand{\gapprompt}[1]{\color{promptColor}{\bfseries #1}}
\newcommand{\gapbrkprompt}[1]{\color{brkpromptColor}{\bfseries #1}}
\newcommand{\gapinput}[1]{\color{gapinputColor}{#1}}
\begin{document}
\logpage{[ 0, 0, 0 ]}
\begin{titlepage}
\mbox{}\vfill
\begin{center}{\maintitlesize \textbf{ utils \mbox{}}}\\
\vfill
\hypersetup{pdftitle= utils }
\markright{\scriptsize \mbox{}\hfill utils \hfill\mbox{}}
{\Huge \textbf{ Utility functions in \textsf{GAP} \mbox{}}}\\
\vfill
{\Huge 0.93 \mbox{}}\\[1cm]
{ 13 November 2025 \mbox{}}\\[1cm]
\mbox{}\\[2cm]
{\Large \textbf{ Thomas Breuer\\
\mbox{}}}\\
{\Large \textbf{ Sebastian Gutsche\\
\mbox{}}}\\
{\Large \textbf{ Max Horn\\
\mbox{}}}\\
{\Large \textbf{ Alexander Hulpke\\
\mbox{}}}\\
{\Large \textbf{ Pedro Garc{\a'\i}a\texttt{\symbol{45}}S{\a'a}nchez\\
\mbox{}}}\\
{\Large \textbf{ Christopher Jefferson\\
\mbox{}}}\\
{\Large \textbf{ Stefan Kohl\\
\mbox{}}}\\
{\Large \textbf{ Frank L{\"u}beck\\
\mbox{}}}\\
{\Large \textbf{ Chris Wensley\\
\mbox{}}}\\
\hypersetup{pdfauthor= Thomas Breuer\\
; Sebastian Gutsche\\
; Max Horn\\
; Alexander Hulpke\\
; Pedro Garc{\a'\i}a\texttt{\symbol{45}}S{\a'a}nchez\\
; Christopher Jefferson\\
; Stefan Kohl\\
; Frank L{\"u}beck\\
; Chris Wensley\\
}
\end{center}\vfill
\mbox{}\\
{\mbox{}\\
\small \noindent \textbf{ Thomas Breuer\\
} Email: \href{mailto://sam@math.rwth-aachen.de} {\texttt{sam@math.rwth\texttt{\symbol{45}}aachen.de}}\\
Homepage: \href{https://www.math.rwth-aachen.de/~Thomas.Breuer} {\texttt{https://www.math.rwth\texttt{\symbol{45}}aachen.de/\texttt{\symbol{126}}Thomas.Breuer}}}\\
{\mbox{}\\
\small \noindent \textbf{ Sebastian Gutsche\\
} Email: \href{mailto://gutsche@mathematik.uni-siegen.de} {\texttt{gutsche@mathematik.uni\texttt{\symbol{45}}siegen.de}}\\
Homepage: \href{https://sebasguts.github.io/} {\texttt{https://sebasguts.github.io/}}}\\
{\mbox{}\\
\small \noindent \textbf{ Max Horn\\
} Email: \href{mailto://mhorn@rptu.de} {\texttt{mhorn@rptu.de}}\\
Homepage: \href{https://github.com/mhorn} {\texttt{https://github.com/mhorn}}}\\
{\mbox{}\\
\small \noindent \textbf{ Alexander Hulpke\\
} Email: \href{mailto://hulpke@math.colostate.edu} {\texttt{hulpke@math.colostate.edu}}\\
Homepage: \href{https://www.math.colostate.edu/~hulpke} {\texttt{https://www.math.colostate.edu/\texttt{\symbol{126}}hulpke}}}\\
{\mbox{}\\
\small \noindent \textbf{ Pedro Garc{\a'\i}a\texttt{\symbol{45}}S{\a'a}nchez\\
} Email: \href{mailto://pedro@ugr.es} {\texttt{pedro@ugr.es}}\\
Homepage: \href{http://www.ugr.es/local/pedro} {\texttt{http://www.ugr.es/local/pedro}}}\\
{\mbox{}\\
\small \noindent \textbf{ Christopher Jefferson\\
} Email: \href{mailto://caj21@st-andrews.ac.uk} {\texttt{caj21@st\texttt{\symbol{45}}andrews.ac.uk}}\\
Homepage: \href{https://caj.host.cs.st-andrews.ac.uk/} {\texttt{https://caj.host.cs.st\texttt{\symbol{45}}andrews.ac.uk/}}}\\
{\mbox{}\\
\small \noindent \textbf{ Stefan Kohl\\
} Email: \href{mailto://stefan@mcs.st-and.ac.uk} {\texttt{stefan@mcs.st\texttt{\symbol{45}}and.ac.uk}}\\
Homepage: \href{https://www.gap-system.org/DevelopersPages/StefanKohl/} {\texttt{https://www.gap\texttt{\symbol{45}}system.org/DevelopersPages/StefanKohl/}}}\\
{\mbox{}\\
\small \noindent \textbf{ Frank L{\"u}beck\\
} Email: \href{mailto://Frank.Luebeck@Math.RWTH-Aachen.De} {\texttt{Frank.Luebeck@Math.RWTH\texttt{\symbol{45}}Aachen.De}}\\
Homepage: \href{https://www.math.rwth-aachen.de/~Frank.Luebeck} {\texttt{https://www.math.rwth\texttt{\symbol{45}}aachen.de/\texttt{\symbol{126}}Frank.Luebeck}}}\\
{\mbox{}\\
\small \noindent \textbf{ Chris Wensley\\
} Email: \href{mailto://cdwensley.maths@btinternet.com} {\texttt{cdwensley.maths@btinternet.com}}\\
Homepage: \href{https://github.com/cdwensley} {\texttt{https://github.com/cdwensley}}}\\
\end{titlepage}
\newpage\setcounter{page}{2}
{\small
\section*{Abstract}
\logpage{[ 0, 0, 1 ]}
The \textsf{Utils} package provides a space for utility functions in a variety of \textsf{GAP} packages to be collected together into a single package. In this way it is
hoped that they will become more visible to package authors.
Any package author who transfers a function to \textsf{Utils} will become an author of \textsf{Utils}.
If deemed appropriate, functions may also be transferred from the main
library.
Bug reports, suggestions and comments are, of course, welcome. Please contact
the last author at \href{mailto://cdwensley.maths@btinternet.com} {\texttt{cdwensley.maths@btinternet.com}} or submit an issue at the GitHub repository \href{https://github.com/gap-packages/utils/issues/} {\texttt{https://github.com/gap\texttt{\symbol{45}}packages/utils/issues/}}. \mbox{}}\\[1cm]
{\small
\section*{Copyright}
\logpage{[ 0, 0, 2 ]}
{\copyright} 2015\texttt{\symbol{45}}2025, The GAP Group.
The \textsf{Utils} package is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version. \mbox{}}\\[1cm]
{\small
\section*{Acknowledgements}
\logpage{[ 0, 0, 3 ]}
This documentation was prepared using the \textsf{GAPDoc} \cite{GAPDoc} and \textsf{AutoDoc} \cite{AutoDoc} packages.
The procedure used to produce new releases uses the package \textsf{GitHubPagesForGAP} \cite{GitHubPagesForGAP} and the package \textsf{ReleaseTools}.
\mbox{}}\\[1cm]
\newpage
\def\contentsname{Contents\logpage{[ 0, 0, 4 ]}}
\tableofcontents
\newpage
\chapter{\textcolor{Chapter }{Introduction}}\label{chap-intro}
\logpage{[ 1, 0, 0 ]}
\hyperdef{L}{X7DFB63A97E67C0A1}{}
{
The \textsf{Utils} package provides a space for utility functions from a variety of \textsf{GAP} packages to be collected together into a single package. In this way it is
hoped that they will become more visible to other package authors. This
package was first distributed as part of the \textsf{GAP} 4.8.2 distribution.
The package is loaded with the command
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@LoadPackage( "utils" ); |
\end{Verbatim}
Functions have been transferred from the following packages:
\begin{itemize}
\item Conversion of a \textsf{GAP} group to a ${\sf Magma}$ output string, taken from various sources including \texttt{other.gi} in the main library.
\end{itemize}
Transfer is complete (for now) for functions from the following packages:
\begin{itemize}
\item \textsf{AutoDoc} \cite{AutoDoc} (with function names changed);
\item \textsf{ResClasses} \cite{ResClasses};
\item \textsf{RCWA} \cite{RCWA};
\item \textsf{XMod} \cite{XMod}.
\end{itemize}
The package may be obtained either as a compressed \texttt{.tar} file or as a \texttt{.zip} file, \texttt{utils\texttt{\symbol{45}}version{\textunderscore}number.tar.gz}, by ftp from one of the following sites:
\begin{itemize}
\item the \textsf{Utils} GitHub release site: \href{https://gap-packages.github.io/utils/} {\texttt{https://gap\texttt{\symbol{45}}packages.github.io/utils/}}.
\item any \textsf{GAP} archive, e.g. \href{https://www.gap-system.org/Packages/packages.html} {\texttt{https://www.gap\texttt{\symbol{45}}system.org/Packages/packages.html}};
\end{itemize}
\index{GitHub repository} The package also has a GitHub repository at: \href{https://github.com/gap-packages/utils} {\texttt{https://github.com/gap\texttt{\symbol{45}}packages/utils}}.
Once the package is loaded, the manual \texttt{doc/manual.pdf} can be found in the documentation folder. The \texttt{html} versions, with or without ${\sf MathJax}$, may be rebuilt as follows:
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@ReadPackage( "utils", "makedoc.g" ); |
\end{Verbatim}
It is possible to check that the package has been installed correctly by
running the test files (which terminates the \textsf{GAP} session):
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@ReadPackage( "utils", "tst/testall.g" );|
Architecture: . . . . .
testing: . . . . .
. . .
#I No errors detected while testing
\end{Verbatim}
Note that functions listed in this manual that are currently in the process of
being transferred are only read from the source package \textsf{Home} (say), and so can only be used if \textsf{Home} has already been loaded. There are no such functions in transition at present.
\section{\textcolor{Chapter }{Information for package authors}}\label{sect-author-info}
\logpage{[ 1, 1, 0 ]}
\hyperdef{L}{X8508AD637B79CEE8}{}
{
A function (or collection of functions) is suitable for transfer from a
package \textsf{Home} to \textsf{Utils} if the following conditions are satisfied.
\begin{itemize}
\item The function is sufficiently non\texttt{\symbol{45}}specialised so that it
might be of use to other authors.
\item The function does not depend on the remaining functions in \textsf{Home}
\item The function does not do what can already be done with a \textsf{GAP} library function.
\item Documentation of the function and test examples are available.
\item When there is more than one active author of \textsf{Home}, they should all be aware (and content) that the transfer is taking place.
\end{itemize}
Authors of packages may be reluctant to let go of their utility functions. The
following principles may help to reassure them. (Suggestions for more items
here are welcome.)
\begin{itemize}
\item A function that has been transferred to \textsf{Utils} will not be changed without the approval of the original author.
\item The current package maintainer has every intention of continuing to maintain \textsf{Utils}. In the event that this proves impossible, the \textsf{GAP} development team will surely find someone to take over.
\item Function names will not be changed unless specifically requested by \textsf{Home}'s author(s) or unless they have the form \texttt{HOME{\textunderscore}FunctionName}.
\item In order to speed up the transfer process, only functions from one package
will be in transition at any given time. Hopefully a week or two will suffice
for most packages.
\item Any package author who transfers a function to \textsf{Utils} will become an author of \textsf{Utils}. (In truth, \textsf{Utils} does not have \emph{authors}, just a large number of \emph{contributors}.)
\end{itemize}
The process for transferring utility functions from \textsf{Home} to \textsf{Utils} is described in Chapter \ref{chap-transfer}. }
}
\chapter{\textcolor{Chapter }{Printing Lists and Iterators}}\label{chap-print}
\logpage{[ 2, 0, 0 ]}
\hyperdef{L}{X83686EE47E4D4F66}{}
{
\section{\textcolor{Chapter }{Printing selected items}}\label{sec-print-select}
\logpage{[ 2, 1, 0 ]}
\hyperdef{L}{X7F6817927F86240F}{}
{
The functions described here print lists or objects with an iterator with one
item per line, either the whole list/iterator or certain subsets:
\begin{itemize}
\item by giving a list of positions of items to be printed, or
\item by specifying a first item and then a regular step.
\end{itemize}
\subsection{\textcolor{Chapter }{PrintSelection (for a list of positions)}}
\logpage{[ 2, 1, 1 ]}\nobreak
\hyperdef{L}{X784638AC84D49870}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PrintSelection({\mdseries\slshape obj, list})\index{PrintSelection@\texttt{PrintSelection}!for a list of positions}
\label{PrintSelection:for a list of positions}
}\hfill{\scriptsize (function)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PrintSelection({\mdseries\slshape obj, first, step[, last]})\index{PrintSelection@\texttt{PrintSelection}!for a first item and a step}
\label{PrintSelection:for a first item and a step}
}\hfill{\scriptsize (function)}}\\
This function, given three (or four) parameters, calls operations \texttt{PrintSelectionFromList} or \texttt{PrintSelectionFromIterator} which prints the \emph{first} item specified, and then the item at every \emph{step}. The fourth parameter is essential when the object being printed is infinite.
Alternatively, given two parameters, with the second parameter a list \texttt{L} of positive integers, only the items at positions in \texttt{L} are printed.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@L := List( [1..20], n -> n^5 );;|
!gapprompt@gap>| !gapinput@PrintSelection( L, [18..20] );|
18 : 1889568
19 : 2476099
20 : 3200000
!gapprompt@gap>| !gapinput@PrintSelection( L, 2, 9 ); |
2 : 32
11 : 161051
20 : 3200000
!gapprompt@gap>| !gapinput@PrintSelection( L, 2, 3, 11 );|
2 : 32
5 : 3125
8 : 32768
11 : 161051
!gapprompt@gap>| !gapinput@s5 := SymmetricGroup( 5 );;|
!gapprompt@gap>| !gapinput@PrintSelection( s5, [30,31,100,101] );|
30 : (1,5)(3,4)
31 : (1,5,2)
100 : (1,4,3)
101 : (1,4)(3,5)
!gapprompt@gap>| !gapinput@PrintSelection( s5, 1, 30 );|
1 : ()
31 : (1,5,2)
61 : (1,2,3)
91 : (1,3,5,2,4)
!gapprompt@gap>| !gapinput@PrintSelection( s5, 9, 11, 43 );|
9 : (2,5,3)
20 : (2,4)
31 : (1,5,2)
42 : (1,5,2,3,4)
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Lists, Sets and Strings}}\label{chap-lists}
\logpage{[ 3, 0, 0 ]}
\hyperdef{L}{X7AE6EFC086C0EB3C}{}
{
\section{\textcolor{Chapter }{Functions for lists}}\label{sec-lists}
\logpage{[ 3, 1, 0 ]}
\hyperdef{L}{X7C3F1E7D878AAA65}{}
{
\subsection{\textcolor{Chapter }{DifferencesList}}
\logpage{[ 3, 1, 1 ]}\nobreak
\hyperdef{L}{X78B7C92681D2F13C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DifferencesList({\mdseries\slshape L})\index{DifferencesList@\texttt{DifferencesList}}
\label{DifferencesList}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{ResClasses}.
It takes a list $L$ of length $n$ and outputs the list of length $n-1$ containing all the differences $L[i]-L[i-1]$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@List( [1..12], n->n^3 );|
[ 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728 ]
!gapprompt@gap>| !gapinput@DifferencesList( last );|
[ 7, 19, 37, 61, 91, 127, 169, 217, 271, 331, 397 ]
!gapprompt@gap>| !gapinput@DifferencesList( last );|
[ 12, 18, 24, 30, 36, 42, 48, 54, 60, 66 ]
!gapprompt@gap>| !gapinput@DifferencesList( last );|
[ 6, 6, 6, 6, 6, 6, 6, 6, 6 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{QuotientsList}}
\logpage{[ 3, 1, 2 ]}\nobreak
\hyperdef{L}{X7975371E865B89BC}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{QuotientsList({\mdseries\slshape L})\index{QuotientsList@\texttt{QuotientsList}}
\label{QuotientsList}
}\hfill{\scriptsize (function)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{FloatQuotientsList({\mdseries\slshape L})\index{FloatQuotientsList@\texttt{FloatQuotientsList}}
\label{FloatQuotientsList}
}\hfill{\scriptsize (function)}}\\
These functions have been transferred from package \textsf{ResClasses}.
They take a list $L$ of length $n$ and output the quotients $L[i]/L[i-1]$ of consecutive entries in $L$. An error is returned if an entry is zero.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@List( [0..10], n -> Factorial(n) );|
[ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ]
!gapprompt@gap>| !gapinput@QuotientsList( last );|
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
!gapprompt@gap>| !gapinput@L := [ 1, 3, 5, -1, -3, -5 ];;|
!gapprompt@gap>| !gapinput@QuotientsList( L );|
[ 3, 5/3, -1/5, 3, 5/3 ]
!gapprompt@gap>| !gapinput@FloatQuotientsList( L );|
[ 3., 1.66667, -0.2, 3., 1.66667 ]
!gapprompt@gap>| !gapinput@QuotientsList( [ 2, 1, 0, -1, -2 ] );|
[ 1/2, 0, fail, 2 ]
!gapprompt@gap>| !gapinput@FloatQuotientsList( [1..10] );|
[ 2., 1.5, 1.33333, 1.25, 1.2, 1.16667, 1.14286, 1.125, 1.11111 ]
!gapprompt@gap>| !gapinput@Product( last );|
10.
\end{Verbatim}
\subsection{\textcolor{Chapter }{SearchCycle}}
\logpage{[ 3, 1, 3 ]}\nobreak
\hyperdef{L}{X86096E73858CFABD}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{SearchCycle({\mdseries\slshape L})\index{SearchCycle@\texttt{SearchCycle}}
\label{SearchCycle}
}\hfill{\scriptsize (operation)}}\\
This function has been transferred from package \textsf{RCWA}.
\texttt{SearchCycle} is a tool to find likely cycles in lists. What, precisely, a \emph{cycle} is, is deliberately fuzzy here, and may possibly even change. The idea is that
the beginning of the list may be anything, following that the same pattern
needs to be repeated several times in order to be recognized as a cycle.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@L := [1..20];; L[1]:=13;; |
!gapprompt@gap>| !gapinput@for i in [1..19] do |
!gapprompt@>| !gapinput@ if IsOddInt(L[i]) then L[i+1]:=3*L[i]+1; else L[i+1]:=L[i]/2; fi;|
!gapprompt@>| !gapinput@ od; |
!gapprompt@gap>| !gapinput@L; |
[ 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4 ]
!gapprompt@gap>| !gapinput@SearchCycle( L ); |
[ 1, 4, 2 ]
!gapprompt@gap>| !gapinput@n := 1;; L := [n];;|
!gapprompt@gap>| !gapinput@for i in [1..100] do n:=(n^2+1) mod 1093; Add(L,n); od;|
!gapprompt@gap>| !gapinput@L; |
[ 1, 2, 5, 26, 677, 363, 610, 481, 739, 715, 795, 272, 754, 157, 604, 848,
1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271,
211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521,
378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272,
754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604,
848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004,
271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004 ]
!gapprompt@gap>| !gapinput@C := SearchCycle( L );|
[ 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754 ]
!gapprompt@gap>| !gapinput@P := Positions( L, 157 );|
[ 14, 26, 38, 50, 62, 74, 86, 98 ]
!gapprompt@gap>| !gapinput@Length( C ); DifferencesList( P );|
12
[ 12, 12, 12, 12, 12, 12, 12 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{RandomCombination}}
\logpage{[ 3, 1, 4 ]}\nobreak
\hyperdef{L}{X7EF06CAD7F35245D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{RandomCombination({\mdseries\slshape S, k})\index{RandomCombination@\texttt{RandomCombination}}
\label{RandomCombination}
}\hfill{\scriptsize (operation)}}\\
This function has been transferred from package \textsf{ResClasses}.
It returns a random unordered $k$\texttt{\symbol{45}}tuple of distinct elements of a set{\nobreakspace}$S$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@## "6 aus 49" is a common lottery in Germany|
!gapprompt@gap>| !gapinput@RandomCombination( [1..49], 6 ); |
[ 2, 16, 24, 26, 37, 47 ]
\end{Verbatim}
}
\section{\textcolor{Chapter }{Distinct and Common Representatives}}\logpage{[ 3, 2, 0 ]}
\hyperdef{L}{X82F443FF84B8FCE3}{}
{
\index{distinct and common representatives}
\subsection{\textcolor{Chapter }{DistinctRepresentatives}}
\logpage{[ 3, 2, 1 ]}\nobreak
\hyperdef{L}{X78105CAA847A888C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DistinctRepresentatives({\mdseries\slshape list})\index{DistinctRepresentatives@\texttt{DistinctRepresentatives}}
\label{DistinctRepresentatives}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CommonRepresentatives({\mdseries\slshape list})\index{CommonRepresentatives@\texttt{CommonRepresentatives}}
\label{CommonRepresentatives}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CommonTransversal({\mdseries\slshape grp, subgrp})\index{CommonTransversal@\texttt{CommonTransversal}}
\label{CommonTransversal}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsCommonTransversal({\mdseries\slshape grp, subgrp, list})\index{IsCommonTransversal@\texttt{IsCommonTransversal}}
\label{IsCommonTransversal}
}\hfill{\scriptsize (operation)}}\\
These operations have been transferred from package \textsf{XMod}.
They deal with lists of subsets of $[1 \ldots n]$ and construct systems of distinct and common representatives using simple,
non\texttt{\symbol{45}}recursive, combinatorial algorithms.
When $L$ is a set of $n$ subsets of $[1 \ldots n]$ and the Hall condition is satisfied (the union of any $k$ subsets has at least $k$ elements), a set of \texttt{DistinctRepresentatives} exists.
When $J,K$ are both lists of $n$ sets, the operation \texttt{CommonRepresentatives} returns two lists: the set of representatives, and a permutation of the
subsets of the second list.
The operation \texttt{CommonTransversal} may be used to provide a common transversal for the sets of left and right
cosets of a subgroup $H$ of a group $G$, although a greedy algorithm is usually quicker. }
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@J := [ [1,2,3], [3,4], [3,4], [1,2,4] ];;|
!gapprompt@gap>| !gapinput@DistinctRepresentatives( J );|
[ 1, 3, 4, 2 ]
!gapprompt@gap>| !gapinput@K := [ [3,4], [1,2], [2,3], [2,3,4] ];;|
!gapprompt@gap>| !gapinput@CommonRepresentatives( J, K );|
[ [ 3, 3, 3, 1 ], [ 1, 3, 4, 2 ] ]
!gapprompt@gap>| !gapinput@d16 := DihedralGroup( IsPermGroup, 16 ); |
Group([ (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) ])
!gapprompt@gap>| !gapinput@SetName( d16, "d16" );|
!gapprompt@gap>| !gapinput@c4 := Subgroup( d16, [ d16.1^2 ] ); |
Group([ (1,3,5,7)(2,4,6,8) ])
!gapprompt@gap>| !gapinput@SetName( c4, "c4" );|
!gapprompt@gap>| !gapinput@RightCosets( d16, c4 );|
[ RightCoset(c4,()), RightCoset(c4,(2,8)(3,7)(4,6)), RightCoset(c4,(1,8,7,6,5,
4,3,2)), RightCoset(c4,(1,8)(2,7)(3,6)(4,5)) ]
!gapprompt@gap>| !gapinput@trans := CommonTransversal( d16, c4 );|
[ (), (2,8)(3,7)(4,6), (1,2,3,4,5,6,7,8), (1,2)(3,8)(4,7)(5,6) ]
!gapprompt@gap>| !gapinput@IsCommonTransversal( d16, c4, trans );|
true
\end{Verbatim}
}
\section{\textcolor{Chapter }{Functions for strings}}\label{sec-strings}
\logpage{[ 3, 3, 0 ]}
\hyperdef{L}{X8033A2FE80FC2F2A}{}
{
\subsection{\textcolor{Chapter }{BlankFreeString}}
\logpage{[ 3, 3, 1 ]}\nobreak
\hyperdef{L}{X870C964E7804B266}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BlankFreeString({\mdseries\slshape obj})\index{BlankFreeString@\texttt{BlankFreeString}}
\label{BlankFreeString}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{ResClasses}.
The result of \texttt{BlankFreeString( obj );} is a composite of the functions \texttt{String( obj )} and \texttt{RemoveCharacters( obj, " " );}.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@gens := GeneratorsOfGroup( DihedralGroup(12) );|
[ f1, f2, f3 ]
!gapprompt@gap>| !gapinput@String( gens ); |
"[ f1, f2, f3 ]"
!gapprompt@gap>| !gapinput@BlankFreeString( gens ); |
"[f1,f2,f3]"
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Number\texttt{\symbol{45}}theoretic functions}}\label{chap-number}
\logpage{[ 4, 0, 0 ]}
\hyperdef{L}{X86E71C1687F2D0AD}{}
{
\section{\textcolor{Chapter }{Functions for integers}}\label{sec-integers}
\logpage{[ 4, 1, 0 ]}
\hyperdef{L}{X7D33B5B17BF785CA}{}
{
\subsection{\textcolor{Chapter }{AllSmoothIntegers (for two integers)}}
\logpage{[ 4, 1, 1 ]}\nobreak
\hyperdef{L}{X8191A031788AC7C0}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllSmoothIntegers({\mdseries\slshape maxp, maxn})\index{AllSmoothIntegers@\texttt{AllSmoothIntegers}!for two integers}
\label{AllSmoothIntegers:for two integers}
}\hfill{\scriptsize (function)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllSmoothIntegers({\mdseries\slshape L, maxp})\index{AllSmoothIntegers@\texttt{AllSmoothIntegers}!for a list and an integer}
\label{AllSmoothIntegers:for a list and an integer}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
\index{smooth integer} The function \texttt{AllSmoothIntegers(\mbox{\texttt{\mdseries\slshape maxp}},\mbox{\texttt{\mdseries\slshape maxn}})} returns the list of all positive integers less than or equal to \mbox{\texttt{\mdseries\slshape maxn}} whose prime factors are all in the list $L = \{p ~|~ p \leqslant maxp, p~\mbox{prime} \}$.
In the alternative form, when $L$ is a list of primes, the function returns the list of all positive integers
whose prime factors lie in $L$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@AllSmoothIntegers( 3, 1000 );|
[ 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 54, 64, 72, 81, 96,
108, 128, 144, 162, 192, 216, 243, 256, 288, 324, 384, 432, 486, 512, 576,
648, 729, 768, 864, 972 ]
!gapprompt@gap>| !gapinput@AllSmoothIntegers( [5,11,17], 1000 );|
[ 1, 5, 11, 17, 25, 55, 85, 121, 125, 187, 275, 289, 425, 605, 625, 935 ]
!gapprompt@gap>| !gapinput@Length( last );|
16
!gapprompt@gap>| !gapinput@List( [3..20], n -> Length( AllSmoothIntegers( [5,11,17], 10^n ) ) );|
[ 16, 29, 50, 78, 114, 155, 212, 282, 359, 452, 565, 691, 831, 992, 1173,
1374, 1595, 1843 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{AllProducts}}
\logpage{[ 4, 1, 2 ]}\nobreak
\hyperdef{L}{X78BE6B8B878D250D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllProducts({\mdseries\slshape L, k})\index{AllProducts@\texttt{AllProducts}}
\label{AllProducts}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
The command \texttt{AllProducts(\mbox{\texttt{\mdseries\slshape L}},\mbox{\texttt{\mdseries\slshape k}})} returns the list of all products of \mbox{\texttt{\mdseries\slshape k}} entries of the list{\nobreakspace}\mbox{\texttt{\mdseries\slshape L}}. Note that every ordering of the entries is used so that, in the commuting
case, there are bound to be repetitions.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@AllProducts([1..4],3); |
[ 1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16, 2, 4, 6, 8, 4, 8, 12,
16, 6, 12, 18, 24, 8, 16, 24, 32, 3, 6, 9, 12, 6, 12, 18, 24, 9, 18, 27,
36, 12, 24, 36, 48, 4, 8, 12, 16, 8, 16, 24, 32, 12, 24, 36, 48, 16, 32,
48, 64 ]
!gapprompt@gap>| !gapinput@Set(last); |
[ 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32, 36, 48, 64 ]
!gapprompt@gap>| !gapinput@AllProducts( [(1,2,3),(2,3,4)], 2 );|
[ (2,4,3), (1,2)(3,4), (1,3)(2,4), (1,3,2) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{RestrictedPartitionsWithoutRepetitions}}
\logpage{[ 4, 1, 3 ]}\nobreak
\hyperdef{L}{X845F46E579CEA43F}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{RestrictedPartitionsWithoutRepetitions({\mdseries\slshape n, S})\index{RestrictedPartitionsWithoutRepetitions@\texttt{Restricted}\-\texttt{Partitions}\-\texttt{Without}\-\texttt{Repetitions}}
\label{RestrictedPartitionsWithoutRepetitions}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
For a positive integer \mbox{\texttt{\mdseries\slshape n}} and a set of positive integers \mbox{\texttt{\mdseries\slshape S}}, this function returns the list of partitions of \mbox{\texttt{\mdseries\slshape n}} into distinct elements of \mbox{\texttt{\mdseries\slshape S}}. Unlike \texttt{RestrictedPartitions}, no repetitions are allowed.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@RestrictedPartitions( 20, [4..10] );|
[ [ 4, 4, 4, 4, 4 ], [ 5, 5, 5, 5 ], [ 6, 5, 5, 4 ], [ 6, 6, 4, 4 ],
[ 7, 5, 4, 4 ], [ 7, 7, 6 ], [ 8, 4, 4, 4 ], [ 8, 6, 6 ], [ 8, 7, 5 ],
[ 8, 8, 4 ], [ 9, 6, 5 ], [ 9, 7, 4 ], [ 10, 5, 5 ], [ 10, 6, 4 ],
[ 10, 10 ] ]
!gapprompt@gap>| !gapinput@RestrictedPartitionsWithoutRepetitions( 20, [4..10] );|
[ [ 10, 6, 4 ], [ 9, 7, 4 ], [ 9, 6, 5 ], [ 8, 7, 5 ] ]
!gapprompt@gap>| !gapinput@RestrictedPartitionsWithoutRepetitions( 10^2, List([1..10], n->n^2 ) );|
[ [ 100 ], [ 64, 36 ], [ 49, 25, 16, 9, 1 ] ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{NextProbablyPrimeInt}}
\logpage{[ 4, 1, 4 ]}\nobreak
\hyperdef{L}{X81708BF4858505E8}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NextProbablyPrimeInt({\mdseries\slshape n})\index{NextProbablyPrimeInt@\texttt{NextProbablyPrimeInt}}
\label{NextProbablyPrimeInt}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
The function \texttt{NextProbablyPrimeInt(\mbox{\texttt{\mdseries\slshape n}})} does the same as \texttt{NextPrimeInt(\mbox{\texttt{\mdseries\slshape n}})} except that for reasons of performance it tests numbers only for \texttt{IsProbablyPrimeInt(\mbox{\texttt{\mdseries\slshape n}})} instead of \texttt{IsPrimeInt(\mbox{\texttt{\mdseries\slshape n}})}. For large \mbox{\texttt{\mdseries\slshape n}}, this function is much faster than \texttt{NextPrimeInt(\mbox{\texttt{\mdseries\slshape n}})}
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@n := 2^251;|
3618502788666131106986593281521497120414687020801267626233049500247285301248
!gapprompt@gap>| !gapinput@NextProbablyPrimeInt( n );|
3618502788666131106986593281521497120414687020801267626233049500247285301313
!gapprompt@gap>| !gapinput@time; |
1
!gapprompt@gap>| !gapinput@NextPrimeInt( n ); |
3618502788666131106986593281521497120414687020801267626233049500247285301313
!gapprompt@gap>| !gapinput@time; |
213
\end{Verbatim}
\subsection{\textcolor{Chapter }{PrimeNumbersIterator}}
\logpage{[ 4, 1, 5 ]}\nobreak
\hyperdef{L}{X8021EEE5787FCA37}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PrimeNumbersIterator({\mdseries\slshape [chunksize]})\index{PrimeNumbersIterator@\texttt{PrimeNumbersIterator}}
\label{PrimeNumbersIterator}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
This function returns an iterator which runs over the prime numbers n
ascending order; it takes an optional argument \texttt{chunksize} which specifies the length of the interval which is sieved in one go (the
default is $10^7$), and which can be used to balance runtime vs. memory consumption. It is
assumed that \texttt{chunksize} is larger than any gap between two consecutive primes within the range one
intends to run the iterator over.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@iter := PrimeNumbersIterator();;|
!gapprompt@gap>| !gapinput@for i in [1..100] do p := NextIterator(iter); od;|
!gapprompt@gap>| !gapinput@p;|
541
!gapprompt@gap>| !gapinput@sum := 0;;|
!gapprompt@gap>| !gapinput@## "prime number race" 1 vs. 3 mod 4|
!gapprompt@gap>| !gapinput@for p in PrimeNumbersIterator() do |
!gapprompt@>| !gapinput@ if p <> 2 then sum := sum + E(4)^(p-1); fi;|
!gapprompt@>| !gapinput@ if sum > 0 then break; fi;|
!gapprompt@>| !gapinput@ od;|
!gapprompt@gap>| !gapinput@p;|
26861
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Groups and homomorphisms}}\label{chap-groups}
\logpage{[ 5, 0, 0 ]}
\hyperdef{L}{X8171DAF2833FF728}{}
{
\section{\textcolor{Chapter }{Functions for groups}}\label{sec-groups}
\logpage{[ 5, 1, 0 ]}
\hyperdef{L}{X7E21E6D285E6B12C}{}
{
\subsection{\textcolor{Chapter }{Comm}}
\logpage{[ 5, 1, 1 ]}\nobreak
\hyperdef{L}{X80761843831B468E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Comm({\mdseries\slshape L})\index{Comm@\texttt{Comm}}
\label{Comm}
}\hfill{\scriptsize (operation)}}\\
This method has been transferred from package \textsf{ResClasses}.
It provides a method for \texttt{Comm} when the argument is a list (enclosed in square brackets), and calls the
function \texttt{LeftNormedComm}.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@Comm( [ (1,2), (2,3) ] );|
(1,2,3)
!gapprompt@gap>| !gapinput@Comm( [(1,2),(2,3),(3,4),(4,5),(5,6)] );|
(1,5,6)
!gapprompt@gap>| !gapinput@Comm(Comm(Comm(Comm((1,2),(2,3)),(3,4)),(4,5)),(5,6)); ## the same|
(1,5,6)
\end{Verbatim}
\subsection{\textcolor{Chapter }{IsCommuting}}
\logpage{[ 5, 1, 2 ]}\nobreak
\hyperdef{L}{X803A050C7A183CCC}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsCommuting({\mdseries\slshape a, b})\index{IsCommuting@\texttt{IsCommuting}}
\label{IsCommuting}
}\hfill{\scriptsize (operation)}}\\
This function has been transferred from package \textsf{ResClasses}.
It tests whether two elements in a group commute.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@D12 := DihedralGroup( 12 );|
!gapprompt@gap>| !gapinput@SetName( D12, "D12" ); |
!gapprompt@gap>| !gapinput@a := D12.1;; b := D12.2;; |
!gapprompt@gap>| !gapinput@IsCommuting( a, b );|
false
\end{Verbatim}
\subsection{\textcolor{Chapter }{ListOfPowers}}
\logpage{[ 5, 1, 3 ]}\nobreak
\hyperdef{L}{X87A8F01286548037}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ListOfPowers({\mdseries\slshape g, exp})\index{ListOfPowers@\texttt{ListOfPowers}}
\label{ListOfPowers}
}\hfill{\scriptsize (operation)}}\\
This function has been transferred from package \textsf{RCWA}.
The operation \texttt{ListOfPowers(g,exp)} returns the list $[g,g^2,...,g^{exp}]$ of powers of the element $g$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@ListOfPowers( 2, 20 );|
[ 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384,
32768, 65536, 131072, 262144, 524288, 1048576 ]
!gapprompt@gap>| !gapinput@ListOfPowers( (1,2,3)(4,5), 12 );|
[ (1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5), (),
(1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5), () ]
!gapprompt@gap>| !gapinput@ListOfPowers( D12.2, 6 );|
[ f2, f3, f2*f3, f3^2, f2*f3^2, of ... ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{GeneratorsAndInverses}}
\logpage{[ 5, 1, 4 ]}\nobreak
\hyperdef{L}{X820B71307E41BEE5}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{GeneratorsAndInverses({\mdseries\slshape G})\index{GeneratorsAndInverses@\texttt{GeneratorsAndInverses}}
\label{GeneratorsAndInverses}
}\hfill{\scriptsize (operation)}}\\
This function has been transferred from package \textsf{RCWA}.
This operation returns a list containing the generators of $G$ followed by the inverses of these generators.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@GeneratorsAndInverses( D12 );|
[ f1, f2, f3, f1, f2*f3^2, f3^2 ]
!gapprompt@gap>| !gapinput@GeneratorsAndInverses( SymmetricGroup(5) ); |
[ (1,2,3,4,5), (1,2), (1,5,4,3,2), (1,2) ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{UpperFittingSeries}}
\logpage{[ 5, 1, 5 ]}\nobreak
\hyperdef{L}{X84CF95227F9D562F}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{UpperFittingSeries({\mdseries\slshape G})\index{UpperFittingSeries@\texttt{UpperFittingSeries}}
\label{UpperFittingSeries}
}\hfill{\scriptsize (attribute)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{LowerFittingSeries({\mdseries\slshape G})\index{LowerFittingSeries@\texttt{LowerFittingSeries}}
\label{LowerFittingSeries}
}\hfill{\scriptsize (attribute)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{FittingLength({\mdseries\slshape G})\index{FittingLength@\texttt{FittingLength}}
\label{FittingLength}
}\hfill{\scriptsize (attribute)}}\\
These three functions have been transferred from package \textsf{ResClasses}.
\index{Fitting series} The upper and lower Fitting series and the Fitting length of a solvable group
are described here: \href{https://en.wikipedia.org/wiki/Fitting_length} {\texttt{https://en.wikipedia.org/wiki/Fitting{\textunderscore}length}}.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@UpperFittingSeries( D12 ); LowerFittingSeries( D12 );|
[ Group([ ]), Group([ f3, f2*f3 ]), Group([ f1, f3, f2*f3 ]) ]
[ D12, Group([ f3 ]), Group([ ]) ]
!gapprompt@gap>| !gapinput@FittingLength( D12 );|
2
!gapprompt@gap>| !gapinput@S4 := SymmetricGroup( 4 );;|
!gapprompt@gap>| !gapinput@UpperFittingSeries( S4 );|
[ Group(()), Group([ (1,2)(3,4), (1,4)(2,3) ]), Group([ (1,2)(3,4), (1,4)
(2,3), (2,4,3) ]), Group([ (3,4), (2,3,4), (1,2)(3,4) ]) ]
!gapprompt@gap>| !gapinput@List( last, StructureDescription );|
[ "1", "C2 x C2", "A4", "S4" ]
!gapprompt@gap>| !gapinput@LowerFittingSeries( S4 );|
[ Sym( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), Group([ (1,4)(2,3), (1,3)
(2,4) ]), Group(()) ]
!gapprompt@gap>| !gapinput@List( last, StructureDescription );|
[ "S4", "A4", "C2 x C2", "1" ]
!gapprompt@gap>| !gapinput@FittingLength( S4);|
3
\end{Verbatim}
}
\section{\textcolor{Chapter }{Left Cosets for Groups}}\label{sec-leftcosets}
\logpage{[ 5, 2, 0 ]}
\hyperdef{L}{X7FE4848B7DE6B3FD}{}
{
\subsection{\textcolor{Chapter }{LeftCoset}}
\logpage{[ 5, 2, 1 ]}\nobreak
\hyperdef{L}{X8340B4537F17DCD3}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{LeftCoset({\mdseries\slshape g, U})\index{LeftCoset@\texttt{LeftCoset}}
\label{LeftCoset}
}\hfill{\scriptsize (operation)}}\\
Since \textsf{GAP} uses right actions by default, the library contains the operation \texttt{RightCoset(U,g)} for constructing the right coset $Ug$ of a subgroup $U \leq G$ and an element $g \in G$. It has been noted in the reference manual that, by inverting all the
elements in $Ug$, the left coset $g^{-1}U$ is obtained.
Just for the sake of completeness, from August 2022 this package provides the
operation \texttt{LeftCoset(g,U)} for constructing the left coset $gU$. Users are strongly recommended to continue to use \texttt{RightCoset} for all serious calculations, since left cosets have a much simpler
implementation and do not behave exactly like right cosets.
The methods for left cosets which are provided generally work by converting $gU$ to $Ug^{-1}$; applying the equivalent method for right cosets; and, if necessary,
converting back again to left cosets.
$G$ acts on left cosets by \texttt{OnLeftInverse}: $(gU)^{g_0} = g_0^{-1}*(gU) = (g_0^{-1}g)U$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@a4 := Group( (1,2,3), (2,3,4) );; SetName( a4, "a4" );|
!gapprompt@gap>| !gapinput@k4 := Group( (1,2)(3,4), (1,3)(2,4) );; SetName( k4, "k4" );|
!gapprompt@gap>| !gapinput@rc := RightCosets( a4, k4 );|
[ RightCoset(k4,()), RightCoset(k4,(2,3,4)), RightCoset(k4,(2,4,3)) ]
!gapprompt@gap>| !gapinput@lc := LeftCosets( a4, k4 );|
[ LeftCoset((),k4), LeftCoset((2,4,3),k4), LeftCoset((2,3,4),k4) ]
!gapprompt@gap>| !gapinput@AsSet( lc[2] );|
[ (2,4,3), (1,2,3), (1,3,4), (1,4,2) ]
!gapprompt@gap>| !gapinput@LeftCoset( (1,4,2), k4 ) = lc[2];|
true
!gapprompt@gap>| !gapinput@Representative( lc[2] );|
(2,4,3)
!gapprompt@gap>| !gapinput@ActingDomain( lc[2] );|
k4
!gapprompt@gap>| !gapinput@(1,4,3) in lc[3];|
true
!gapprompt@gap>| !gapinput@(1,2,3)*lc[2] = lc[3];|
true
!gapprompt@gap>| !gapinput@lc[2]^(1,3,2) = lc[3];|
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{Inverse}}\label{subsec-inverse}
\logpage{[ 5, 2, 2 ]}
\hyperdef{L}{X793E48267EF5FD77}{}
{
The inverse of the left coset $gU$ is the right coset $Ug^{-1}$, and conversely. This is an abuse of the attribute \texttt{Inverse}, since the standard requirement, that $x*x^{-1}$ is an identity, does not hold.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@Inverse( rc[3] ) = lc[3];|
true
!gapprompt@gap>| !gapinput@Inverse( lc[2] ) = rc[2];|
true
\end{Verbatim}
}
}
\section{\textcolor{Chapter }{Functions for group homomorphisms}}\label{sec-homomorphisms}
\logpage{[ 5, 3, 0 ]}
\hyperdef{L}{X80A512877F515DE7}{}
{
\subsection{\textcolor{Chapter }{EpimorphismByGenerators}}
\logpage{[ 5, 3, 1 ]}\nobreak
\hyperdef{L}{X80C9A0B583FEA7B9}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{EpimorphismByGenerators({\mdseries\slshape G, H})\index{EpimorphismByGenerators@\texttt{EpimorphismByGenerators}}
\label{EpimorphismByGenerators}
}\hfill{\scriptsize (operation)}}\\
This function has been transferred from package \textsf{RCWA}.
It constructs a group homomorphism which maps the generators of $G$ to those of $H$. Its intended use is when $G$ is a free group, and a warning is printed when this is not the case. Note that
anything may happen if the resulting map is not a homomorphism!
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@G := Group( (1,2,3), (3,4,5), (5,6,7), (7,8,9) );;|
!gapprompt@gap>| !gapinput@phi := EpimorphismByGenerators( FreeGroup("a","b","c","d"), G );|
[ a, b, c, d ] -> [ (1,2,3), (3,4,5), (5,6,7), (7,8,9) ]
!gapprompt@gap>| !gapinput@PreImagesRepresentativeNC( phi, (1,2,3,4,5,6,7,8,9) );|
d*c*b*a
!gapprompt@gap>| !gapinput@a := G.1;; b := G.2;; c := G.3;; d := G.4;;|
!gapprompt@gap>| !gapinput@d*c*b*a;|
(1,2,3,4,5,6,7,8,9)
!gapprompt@gap>| !gapinput@## note that it is easy to produce nonsense: |
!gapprompt@gap>| !gapinput@epi := EpimorphismByGenerators( Group((1,2,3)), Group((8,9)) );|
Warning: calling GroupHomomorphismByImagesNC without checks
[ (1,2,3) ] -> [ (8,9) ]
!gapprompt@gap>| !gapinput@IsGroupHomomorphism( epi );|
true
!gapprompt@gap>| !gapinput@Image( epi, (1,2,3) ); |
()
!gapprompt@gap>| !gapinput@Image( epi, (1,3,2) );|
(8,9)
\end{Verbatim}
\subsection{\textcolor{Chapter }{Pullback}}
\logpage{[ 5, 3, 2 ]}\nobreak
\hyperdef{L}{X7C705F2A79F8E43C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Pullback({\mdseries\slshape hom1, hom2})\index{Pullback@\texttt{Pullback}}
\label{Pullback}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PullbackInfo({\mdseries\slshape G})\index{PullbackInfo@\texttt{PullbackInfo}}
\label{PullbackInfo}
}\hfill{\scriptsize (attribute)}}\\
If $\phi_1 : G_1 \to H$ and $\phi_2 : G_2 \to H$ are two group homomorphisms with the same range, then their \emph{pullback} is the subgroup of $G_1 \times G_2$ consisting of those elements $(g_1,g_2)$ such that $\phi_1 g_1 = \phi_2 g_2$.
The attribute \texttt{PullbackInfo} of a pullback group \texttt{P} is similar to \texttt{DirectProductInfo} for a direct product of groups. Its value is a record with the following
components:
\begin{description}
\item[{\texttt{directProduct}}] the direct product $G_1 \times G_2$, and
\item[{\texttt{projections}}] a list with the two projections onto $G_1$ and $G_2$.
\end{description}
There are no embeddings in this record, but it is possible to use the
embeddings into the direct product, see \texttt{Embedding} (\textbf{Reference: Embedding}).
}
\begin{Verbatim}[commandchars=@|C,fontsize=\small,frame=single,label=Example]
@gapprompt|gap>C @gapinput|s4 := Group( (1,2),(2,3),(3,4) );;C
@gapprompt|gap>C @gapinput|s3 := Group( (5,6),(6,7) );;C
@gapprompt|gap>C @gapinput|c3 := Subgroup( s3, [ (5,6,7) ] );;C
@gapprompt|gap>C @gapinput|f := GroupHomomorphismByImages( s4, s3, C
@gapprompt|>C @gapinput| [(1,2),(2,3),(3,4)], [(5,6),(6,7),(5,6)] );; C
@gapprompt|gap>C @gapinput|i := GroupHomomorphismByImages( c3, s3, [(5,6,7)], [(5,6,7)] );; C
@gapprompt|gap>C @gapinput|Pfi := Pullback( f, i );C
Group([ (2,3,4)(5,7,6), (1,2)(3,4) ])
@gapprompt|gap>C @gapinput|StructureDescription( Pfi );C
"A4"
@gapprompt|gap>C @gapinput|info := PullbackInfo( Pfi );C
rec( directProduct := Group([ (1,2), (2,3), (3,4), (5,6,7) ]),
projections := [ [ (2,3,4)(5,7,6), (1,2)(3,4) ] -> [ (2,3,4), (1,2)(3,4) ],
[ (2,3,4)(5,7,6), (1,2)(3,4) ] -> [ (5,7,6), () ] ] )
@gapprompt|gap>C @gapinput|g := (1,2,3)(5,6,7);; C
@gapprompt|gap>C @gapinput|ImageElm( info!.projections[1], g );C
(1,2,3)
@gapprompt|gap>C @gapinput|ImageElm( info!.projections[2], g );C
(5,6,7)
@gapprompt|gap>C @gapinput|dp := info!.directProduct;; C
@gapprompt|gap>C @gapinput|a := ImageElm( Embedding( dp, 1 ), (1,4,3) );; C
@gapprompt|gap>C @gapinput|b := ImageElm( Embedding( dp, 2 ), (5,7,6) );; C
@gapprompt|gap>C @gapinput|a*b in Pfi;C
true
\end{Verbatim}
\subsection{\textcolor{Chapter }{CentralProduct}}
\logpage{[ 5, 3, 3 ]}\nobreak
\hyperdef{L}{X78DD2C617B992BE2}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CentralProduct({\mdseries\slshape G1, G2, Z1, Phi})\index{CentralProduct@\texttt{CentralProduct}}
\label{CentralProduct}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CentralProductInfo({\mdseries\slshape G})\index{CentralProductInfo@\texttt{CentralProductInfo}}
\label{CentralProductInfo}
}\hfill{\scriptsize (attribute)}}\\
This function was added by Thomas Breuer, following discussions with Hongyi
Zhao (see \href{https://github.com/gap-packages/hap/issues/73} {\texttt{https://github.com/gap\texttt{\symbol{45}}packages/hap/issues/73}}).
Let \mbox{\texttt{\mdseries\slshape G1}} and \mbox{\texttt{\mdseries\slshape G2}} be two groups, \mbox{\texttt{\mdseries\slshape Z1}} be a central subgroup of \mbox{\texttt{\mdseries\slshape G1}}, and \mbox{\texttt{\mdseries\slshape Phi}} be an isomorphism from \mbox{\texttt{\mdseries\slshape Z1}} to a central subgroup of \mbox{\texttt{\mdseries\slshape G2}}. The \emph{central product} defined by these arguments is the factor group of the direct product of \mbox{\texttt{\mdseries\slshape G1}} and \mbox{\texttt{\mdseries\slshape G2}} by the central subgroup $\{ (z, (\mbox{\texttt{\mdseries\slshape Phi}}(z))^{-1}) : z \in \mbox{\texttt{\mdseries\slshape Z1}} \}$.
The attribute \texttt{CentralProductInfo} of a group $G$ that has been created by \texttt{CentralProduct} is similar to \texttt{PullbackInfo} (\ref{PullbackInfo}) for pullback groups. Its value is a record with the following components.
\begin{description}
\item[{\texttt{projection}}] the epimorphism from the direct product of \mbox{\texttt{\mdseries\slshape G1}} and \mbox{\texttt{\mdseries\slshape G2}} to $G$, and
\item[{\texttt{phi}}] the map \mbox{\texttt{\mdseries\slshape Phi}}.
\end{description}
Note that one can access the direct product as the \texttt{Source} (\textbf{Reference: Source}) value of the \texttt{projection} map, and one can access \mbox{\texttt{\mdseries\slshape G1}} and \mbox{\texttt{\mdseries\slshape G2}} as the two embeddings of this direct product, see \texttt{Embedding} (\textbf{Reference: Embedding}).
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@g1 := DihedralGroup( 8 );|
!gapprompt@gap>| !gapinput@c1 := Centre( g1 );|
Group([ f3 ])
!gapprompt@gap>| !gapinput@cp1 := CentralProduct( g1, g1, c1, IdentityMapping( c1 ) );|
Group([ f1, f2, f5, f3, f4, f5 ])
!gapprompt@gap>| !gapinput@IdGroup( cp1 ) = IdGroup( ExtraspecialGroup( 2^5, "+" ) );|
true
!gapprompt@gap>| !gapinput@g2 := QuaternionGroup( 8 );|
!gapprompt@gap>| !gapinput@c2 := Centre( g2 );|
Group([ y2 ])
!gapprompt@gap>| !gapinput@cp2 := CentralProduct( g2, g2, c2, IdentityMapping( c2 ) );|
Group([ f1, f2, f5, f3, f4, f5 ])
!gapprompt@gap>| !gapinput@IdGroup( cp2 ) = IdGroup( ExtraspecialGroup( 2^5, "+" ) );|
true
!gapprompt@gap>| !gapinput@info2 := CentralProductInfo( cp2 );|
rec( phi := IdentityMapping( Group([ y2 ]) ),
projection := [ f1, f2, f3, f4, f5, f6 ] -> [ f1, f2, f5, f3, f4, f5 ] )
!gapprompt@gap>| !gapinput@Source( Embedding( Source( info2.projection ), 1 ) ) = g2;|
true
\end{Verbatim}
}
\subsection{\textcolor{Chapter }{IdempotentEndomorphisms}}
\logpage{[ 5, 3, 4 ]}\nobreak
\hyperdef{L}{X801038CB808FC956}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IdempotentEndomorphisms({\mdseries\slshape G})\index{IdempotentEndomorphisms@\texttt{IdempotentEndomorphisms}}
\label{IdempotentEndomorphisms}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IdempotentEndomorphismsData({\mdseries\slshape G})\index{IdempotentEndomorphismsData@\texttt{IdempotentEndomorphismsData}}
\label{IdempotentEndomorphismsData}
}\hfill{\scriptsize (attribute)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IdempotentEndomorphismsWithImage({\mdseries\slshape genG, R})\index{IdempotentEndomorphismsWithImage@\texttt{IdempotentEndomorphismsWithImage}}
\label{IdempotentEndomorphismsWithImage}
}\hfill{\scriptsize (operation)}}\\
An endomorphism $f : G \to G$ is idempotent if $f^2=f$. It has an image $R \leqslant G$; is the identity map when restricted to $R$; and has a kernel $N$ which has trivial intersection with $R$ and has size $|G|/|R|$.
The operation \texttt{IdempotentEndomorphismsWithImage(genG,R)} returns a list of the images of the generating set \texttt{genG} of a group $G$ under the idempotent endomorphisms with image $R$.
The attribute \texttt{IdempotentEndomorphismsData(G)} returns a record \texttt{data} with fields \texttt{data.gens}, a fixed generating set for $G$, and \texttt{data.images} a list of the non\texttt{\symbol{45}}empty outputs of \texttt{IdempotentEndomorphismsWithImage(genG,R)} obtained by iterating over all subgroups of $G$.
The operation \texttt{IdempotentEndomorphisms(G)} returns the list of these mappings obtained using \texttt{IdempotentEndomorphismsData(G)}. The first of these is the zero map, the second is the identity.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@gens := [ (1,2,3,4), (1,2)(3,4) ];; |
!gapprompt@gap>| !gapinput@d8 := Group( gens );;|
!gapprompt@gap>| !gapinput@SetName( d8, "d8" );|
!gapprompt@gap>| !gapinput@c2 := Subgroup( d8, [ (2,4) ] );;|
!gapprompt@gap>| !gapinput@IdempotentEndomorphismsWithImage( gens, c2 );|
[ [ (), (2,4) ], [ (2,4), () ] ]
!gapprompt@gap>| !gapinput@IdempotentEndomorphismsData( d8 );|
rec( gens := [ (1,2,3,4), (1,2)(3,4) ],
images := [ [ [ (), () ] ], [ [ (), (2,4) ], [ (2,4), () ] ],
[ [ (), (1,3) ], [ (1,3), () ] ],
[ [ (), (1,2)(3,4) ], [ (1,2)(3,4), (1,2)(3,4) ] ],
[ [ (), (1,4)(2,3) ], [ (1,4)(2,3), (1,4)(2,3) ] ],
[ [ (1,2,3,4), (1,2)(3,4) ] ] ] )
!gapprompt@gap>| !gapinput@List( last.images, L -> Length(L) );|
[ 1, 2, 2, 2, 2, 1 ]
!gapprompt@gap>| !gapinput@IdempotentEndomorphisms( d8 ); |
[ [ (1,2,3,4), (1,2)(3,4) ] -> [ (), () ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (2,4) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (2,4), () ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,3) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,3), () ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,2)(3,4) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,2)(3,4), (1,2)(3,4) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,4)(2,3) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,4)(2,3), (1,4)(2,3) ],
[ (1,2,3,4), (1,2)(3,4) ] -> [ (1,2,3,4), (1,2)(3,4) ] ]
\end{Verbatim}
The quaternion group \texttt{q8} is an example of a group with a tail: there is only one subgroup in the
lattice which covers the identity subgroup. The only idempotent isomorphisms
of such groups are the identity mapping and the zero mapping because the only
pairs $N,R$ are the whole group and the identity subgroup.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@q8 := QuaternionGroup( 8 );;|
!gapprompt@gap>| !gapinput@IdempotentEndomorphisms( q8 );|
[ [ x, y ] -> [ of ..., of ... ], [ x, y ] -> [ x, y ] ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{DirectProductOfFunctions}}
\logpage{[ 5, 3, 5 ]}\nobreak
\hyperdef{L}{X81FA9E6C7F3B9238}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DirectProductOfFunctions({\mdseries\slshape G, H, f1, f2})\index{DirectProductOfFunctions@\texttt{DirectProductOfFunctions}}
\label{DirectProductOfFunctions}
}\hfill{\scriptsize (operation)}}\\
Given group homomorphisms $f_1 : G_1 \to G_2$ and $f_2 : H_1 \to H_2$, this operation return the product homomorphism $f_1 \times f_2 : G_1 \times G_2 \to H_1 \times H_2$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@c4 := Group( (1,2,3,4) );; |
!gapprompt@gap>| !gapinput@c2 := Group( (5,6) );; |
!gapprompt@gap>| !gapinput@f1 := GroupHomomorphismByImages( c4, c2, [(1,2,3,4)], [(5,6)] );;|
!gapprompt@gap>| !gapinput@c3 := Group( (1,2,3) );; |
!gapprompt@gap>| !gapinput@c6 := Group( (1,2,3,4,5,6) );; |
!gapprompt@gap>| !gapinput@f2 := GroupHomomorphismByImages( c3, c6, [(1,2,3)], [(1,3,5)(2,4,6)] );; |
!gapprompt@gap>| !gapinput@c4c3 := DirectProduct( c4, c3 ); |
Group([ (1,2,3,4), (5,6,7) ])
!gapprompt@gap>| !gapinput@c2c6 := DirectProduct( c2, c6 ); |
Group([ (1,2), (3,4,5,6,7,8) ])
!gapprompt@gap>| !gapinput@f := DirectProductOfFunctions( c4c3, c2c6, f1, f2 ); |
[ (1,2,3,4), (5,6,7) ] -> [ (1,2), (3,5,7)(4,6,8) ]
!gapprompt@gap>| !gapinput@ImageElm( f, (1,4,3,2)(5,7,6) ); |
(1,2)(3,7,5)(4,8,6)
\end{Verbatim}
\subsection{\textcolor{Chapter }{DirectProductOfAutomorphismGroups}}
\logpage{[ 5, 3, 6 ]}\nobreak
\hyperdef{L}{X7CB2D5F27F4182AF}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DirectProductOfAutomorphismGroups({\mdseries\slshape A1, A2})\index{DirectProductOfAutomorphismGroups@\texttt{DirectProductOfAutomorphismGroups}}
\label{DirectProductOfAutomorphismGroups}
}\hfill{\scriptsize (operation)}}\\
Let $A_1,A_2$ be groups of automorphism of groups $G_1,G_2$ respectively. The output of this function is a group $A_1 \times A_2$ of automorphisms of $G_1 \times G_2$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@c9 := Group( (1,2,3,4,5,6,7,8,9) );; |
!gapprompt@gap>| !gapinput@ac9 := AutomorphismGroup( c9 );; |
!gapprompt@gap>| !gapinput@q8 := QuaternionGroup( IsPermGroup, 8 );;|
!gapprompt@gap>| !gapinput@aq8 := AutomorphismGroup( q8 );;|
!gapprompt@gap>| !gapinput@A := DirectProductOfAutomorphismGroups( ac9, aq8 );|
!gapprompt@gap>| !gapinput@genA := GeneratorsOfGroup( A );;|
!gapprompt@gap>| !gapinput@G := Source( genA[1] );|
Group([ (1,2,3,4,5,6,7,8,9), (10,14,12,16)(11,17,13,15), (10,11,12,13)
(14,15,16,17) ])
!gapprompt@gap>| !gapinput@a := genA[1]*genA[5]; |
[ (1,2,3,4,5,6,7,8,9), (10,14,12,16)(11,17,13,15), (10,11,12,13)(14,15,16,17)
] -> [ (1,3,5,7,9,2,4,6,8), (10,16,12,14)(11,15,13,17),
(10,11,12,13)(14,15,16,17) ]
!gapprompt@gap>| !gapinput@ImageElm( a, (1,9,8,7,6,5,4,3,2)(10,14,12,16)(11,17,13,15) );|
(1,8,6,4,2,9,7,5,3)(10,16,12,14)(11,15,13,17)
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Matrices}}\label{chap-matrix}
\logpage{[ 6, 0, 0 ]}
\hyperdef{L}{X812CCAB278643A59}{}
{
\section{\textcolor{Chapter }{Some operations for matrices}}\label{sec-matrix-ops}
\logpage{[ 6, 1, 0 ]}
\hyperdef{L}{X802118FB7C94D6BA}{}
{
\subsection{\textcolor{Chapter }{DirectSumDecompositionMatrices}}
\logpage{[ 6, 1, 1 ]}\nobreak
\hyperdef{L}{X787B89237E1398B6}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DirectSumDecompositionMatrices({\mdseries\slshape M})\index{DirectSumDecompositionMatrices@\texttt{DirectSumDecompositionMatrices}}
\label{DirectSumDecompositionMatrices}
}\hfill{\scriptsize (operation)}}\\
In June 2023 Hongyi Zhao asked in the Forum for a function to implement matrix
decomposition into blocks. Such a function was then provided by Pedro
Garc{\a'\i}a\texttt{\symbol{45}}S{\a'a}nchez. Hongyi Zhao then requested that
the function be added to \textsf{Utils}. What is provided here is a revised version of the original solution,
returning a list of decompositions.
This function is a partial inverse to the undocumented library operation \texttt{DirectSumMat}. So if $L$ is the list of diagonal decompositions of a matrix $M$ then each entry in $L$ is a list of matrices, and the direct sum of each of these lists is equal to
the original $M$.
In the following examples, $M_6$ is an obvious direct sum with $3$ blocks. $M_4$ is an example with three decompositions, while $M_8 = M_4 \oplus M_4$ has $16$ decompositions (not listed).
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@M6 := [ [1,2,0,0,0,0], [3,4,0,0,0,0], [5,6,0,0,0,0], |
!gapprompt@>| !gapinput@ [0,0,9,0,0,0], [0,0,0,1,2,3], [0,0,0,4,5,6] ];;|
!gapprompt@gap>| !gapinput@Display( M6 );|
[ [ 1, 2, 0, 0, 0, 0 ],
[ 3, 4, 0, 0, 0, 0 ],
[ 5, 6, 0, 0, 0, 0 ],
[ 0, 0, 9, 0, 0, 0 ],
[ 0, 0, 0, 1, 2, 3 ],
[ 0, 0, 0, 4, 5, 6 ] ]
!gapprompt@gap>| !gapinput@L6 := DirectSumDecompositionMatrices( M6 );|
[ [ [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ], [ [ 9 ] ], [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
] ]
!gapprompt@gap>| !gapinput@M4 := [ [0,3,0,0], [0,0,0,0], [0,0,0,0], [0,0,4,0] ];;|
!gapprompt@gap>| !gapinput@Display( M4 );|
[ [ 0, 3, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 4, 0 ] ]
!gapprompt@gap>| !gapinput@L4 := DirectSumDecompositionMatrices( M4 );|
[ [ [ [ 0, 3 ] ], [ [ 0, 0 ], [ 0, 0 ], [ 4, 0 ] ] ],
[ [ [ 0, 3 ], [ 0, 0 ] ], [ [ 0, 0 ], [ 4, 0 ] ] ],
[ [ [ 0, 3 ], [ 0, 0 ], [ 0, 0 ] ], [ [ 4, 0 ] ] ] ]
!gapprompt@gap>| !gapinput@for L in L4 do |
!gapprompt@>| !gapinput@ A := DirectSumMat( L );; |
!gapprompt@>| !gapinput@ if ( A = M4 ) then Print( "yes, A = M4\n" ); fi; |
!gapprompt@>| !gapinput@ od;|
yes, A = M4
yes, A = M4
yes, A = M4
!gapprompt@gap>| !gapinput@M8 := DirectSumMat( M4, M4 );; |
!gapprompt@gap>| !gapinput@Display( M8 );|
[ [ 0, 3, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 4, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 3, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 4, 0 ] ]
!gapprompt@gap>| !gapinput@L8 := DirectSumDecompositionMatrices( M8 );;|
!gapprompt@gap>| !gapinput@Length( L8 ); |
16
\end{Verbatim}
The current method does not, however, catch all possible decompositions. In
the following example the matrix $M_5$ has its third row and third column extirely zero, and the only decomposition
found has a $[0]$ factor. There are clearly two $2$\texttt{\symbol{45}}factor decompositions with a $2$\texttt{\symbol{45}}by\texttt{\symbol{45}}$3$ and a $3$\texttt{\symbol{45}}by\texttt{\symbol{45}}$2$ factor, but these are not found at present.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@M5 := [ [1,2,0,0,0], [3,4,0,0,0], [0,0,0,0,0],|
!gapprompt@>| !gapinput@ [0,0,0,6,7], [0,0,0,8,9] ];;|
!gapprompt@gap>| !gapinput@Display(M5);|
[ [ 1, 2, 0, 0, 0 ],
[ 3, 4, 0, 0, 0 ],
[ 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 6, 7 ],
[ 0, 0, 0, 8, 9 ] ]
!gapprompt@gap>| !gapinput@L5 := DirectSumDecompositionMatrices( M5 ); |
[ [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 0 ] ], [ [ 6, 7 ], [ 8, 9 ] ] ] ]
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Iterators}}\label{chap-iterator}
\logpage{[ 7, 0, 0 ]}
\hyperdef{L}{X85A3F00985453F95}{}
{
\section{\textcolor{Chapter }{Some iterators for groups and their isomorphisms}}\label{sec-group-iters}
\logpage{[ 7, 1, 0 ]}
\hyperdef{L}{X7BB5350081B27D17}{}
{
\index{Iterators} The motivation for adding these operations is partly to give a simple example
of an iterator for a list that does not yet exist, and need not be created.
\subsection{\textcolor{Chapter }{AllIsomorphismsIterator}}
\logpage{[ 7, 1, 1 ]}\nobreak
\hyperdef{L}{X7F8B54D1806C762D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllIsomorphismsIterator({\mdseries\slshape G, H})\index{AllIsomorphismsIterator@\texttt{AllIsomorphismsIterator}}
\label{AllIsomorphismsIterator}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllIsomorphismsNumber({\mdseries\slshape G, H})\index{AllIsomorphismsNumber@\texttt{AllIsomorphismsNumber}}
\label{AllIsomorphismsNumber}
}\hfill{\scriptsize (operation)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllIsomorphisms({\mdseries\slshape G, H})\index{AllIsomorphisms@\texttt{AllIsomorphisms}}
\label{AllIsomorphisms}
}\hfill{\scriptsize (operation)}}\\
The main \textsf{GAP} library contains functions producing complete lists of group homomorphisms
such as \texttt{AllHomomorphisms}; \texttt{AllEndomorphisms} and \texttt{AllAutomorphisms}. Here we add the missing \texttt{AllIsomorphisms(G,H)} for a list of isomorphisms from $G$ to $H$. The method is simple \texttt{\symbol{45}}\texttt{\symbol{45}} find one
isomorphism $G \to H$ and compose this with all the automorphisms of $G$. In all these cases it may not be desirable to construct a list of
homomorphisms, but just implement an iterator, and that is what is done here.
The operation \texttt{AllIsomorphismsNumber} returns the number of isomorphisms iterated over (this is, of course, just the
order of the automorphisms group). The operation \texttt{AllIsomorphisms} produces the list or isomorphisms.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@G := SmallGroup( 6,1);; |
!gapprompt@gap>| !gapinput@iter := AllIsomorphismsIterator( G, s3 );;|
!gapprompt@gap>| !gapinput@NextIterator( iter );|
[ f1, f2 ] -> [ (6,7), (5,6,7) ]
!gapprompt@gap>| !gapinput@n := AllIsomorphismsNumber( G, s3 );|
6
!gapprompt@gap>| !gapinput@AllIsomorphisms( G, s3 );|
[ [ f1, f2 ] -> [ (6,7), (5,6,7) ], [ f1, f2 ] -> [ (5,7), (5,6,7) ],
[ f1, f2 ] -> [ (5,6), (5,7,6) ], [ f1, f2 ] -> [ (6,7), (5,7,6) ],
[ f1, f2 ] -> [ (5,7), (5,7,6) ], [ f1, f2 ] -> [ (5,6), (5,6,7) ] ]
!gapprompt@gap>| !gapinput@iter := AllIsomorphismsIterator( G, s3 );;|
!gapprompt@gap>| !gapinput@for h in iter do Print( ImageElm( h, G.1 ) = (6,7), ", " ); od;|
true, false, false, true, false, false,
\end{Verbatim}
\subsection{\textcolor{Chapter }{AllSubgroupsIterator}}
\logpage{[ 7, 1, 2 ]}\nobreak
\hyperdef{L}{X831DA5AE8437578F}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllSubgroupsIterator({\mdseries\slshape G})\index{AllSubgroupsIterator@\texttt{AllSubgroupsIterator}}
\label{AllSubgroupsIterator}
}\hfill{\scriptsize (operation)}}\\
The manual entry for the operation \texttt{AllSubgroups} states that it is only intended to be used on small examples in a classroom
situation. Access to all subgroups was required by the \textsf{XMod} package, so this iterator was introduced here. It used the operations \texttt{LatticeSubgroups(G)} and \texttt{ConjugacyClassesSubgroups(lat)}, and then iterates over the entries in these classes.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@c3c3 := Group( (1,2,3), (4,5,6) );; |
!gapprompt@gap>| !gapinput@iter := AllSubgroupsIterator( c3c3 );|
!gapprompt@gap>| !gapinput@while not IsDoneIterator(iter) do Print(NextIterator(iter),"\n"); od;|
Group( () )
Group( [ (4,5,6) ] )
Group( [ (1,2,3) ] )
Group( [ (1,2,3)(4,5,6) ] )
Group( [ (1,3,2)(4,5,6) ] )
Group( [ (4,5,6), (1,2,3) ] )
\end{Verbatim}
}
\section{\textcolor{Chapter }{Operations on iterators}}\label{sec-iter-ops}
\logpage{[ 7, 2, 0 ]}
\hyperdef{L}{X85413EED812C6497}{}
{
This section considers ways of producing an iterator from one or more
iterators. It may be that operations equivalent to these are available
elsewhere in the library \texttt{\symbol{45}}\texttt{\symbol{45}} if so, the
ones here can be removed in due course.
\subsection{\textcolor{Chapter }{CartesianIterator}}
\logpage{[ 7, 2, 1 ]}\nobreak
\hyperdef{L}{X87395A9181A35301}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CartesianIterator({\mdseries\slshape iter1, iter2})\index{CartesianIterator@\texttt{CartesianIterator}}
\label{CartesianIterator}
}\hfill{\scriptsize (operation)}}\\
This iterator returns all pairs $[x,y]$ where $x$ is the output of a first iterator and $y$ is the output of a second iterator.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@it1 := Iterator( [ 1, 2, 3 ] );;|
!gapprompt@gap>| !gapinput@it2 := Iterator( [ 4, 5, 6 ] );;|
!gapprompt@gap>| !gapinput@iter := CartesianIterator( it1, it2 );;|
!gapprompt@gap>| !gapinput@while not IsDoneIterator(iter) do Print(NextIterator(iter),"\n"); od;|
[ 1, 4 ]
[ 1, 5 ]
[ 1, 6 ]
[ 2, 4 ]
[ 2, 5 ]
[ 2, 6 ]
[ 3, 4 ]
[ 3, 5 ]
[ 3, 6 ]
\end{Verbatim}
\subsection{\textcolor{Chapter }{UnorderedPairsIterator}}
\logpage{[ 7, 2, 2 ]}\nobreak
\hyperdef{L}{X7C95E27987A812EA}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{UnorderedPairsIterator({\mdseries\slshape iter})\index{UnorderedPairsIterator@\texttt{UnorderedPairsIterator}}
\label{UnorderedPairsIterator}
}\hfill{\scriptsize (operation)}}\\
This operation returns pairs $[x,y]$ where $x,y$ are output from a given iterator \texttt{iter}. Unlike the output from \texttt{CartesianIterator(iter,iter)}, unordered pairs are returned. In the case $L = [1,2,3,\ldots]$ the pairs are ordered as $[1,1],[1,2],[2,2],[1,3],[2,3],[3,3],\ldots$.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@L := [6,7,8,9];;|
!gapprompt@gap>| !gapinput@iterL := IteratorList( L );; |
!gapprompt@gap>| !gapinput@pairsL := UnorderedPairsIterator( iterL );; |
!gapprompt@gap>| !gapinput@while not IsDoneIterator(pairsL) do Print(NextIterator(pairsL),"\n"); od;|
[ 6, 6 ]
[ 6, 7 ]
[ 7, 7 ]
[ 6, 8 ]
[ 7, 8 ]
[ 8, 8 ]
[ 6, 9 ]
[ 7, 9 ]
[ 8, 9 ]
[ 9, 9 ]
!gapprompt@gap>| !gapinput@iter4 := IteratorList( [ 4 ] );|
!gapprompt@gap>| !gapinput@pairs4 := UnorderedPairsIterator(iter4);|
!gapprompt@gap>| !gapinput@NextIterator( pairs4 );|
[ 4, 4 ]
!gapprompt@gap>| !gapinput@IsDoneIterator( pairs4 );|
true
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Records}}\label{chap-record}
\logpage{[ 8, 0, 0 ]}
\hyperdef{L}{X7AA1073C7E943DD7}{}
{
\section{\textcolor{Chapter }{Functions for records}}\label{sec-records}
\logpage{[ 8, 1, 0 ]}
\hyperdef{L}{X82B3D1D583CDF0E5}{}
{
\subsection{\textcolor{Chapter }{AssignGlobals}}
\logpage{[ 8, 1, 1 ]}\nobreak
\hyperdef{L}{X84D82EB579B2ACCD}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AssignGlobals({\mdseries\slshape rec})\index{AssignGlobals@\texttt{AssignGlobals}}
\label{AssignGlobals}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
It assigns the record components of \mbox{\texttt{\mdseries\slshape rec}} to global variables with the same names.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@r := rec( a := 1, b := 2, c := 3 );; |
!gapprompt@gap>| !gapinput@AssignGlobals( r );|
The following global variables have been assigned:
[ "a", "b", "c" ]
!gapprompt@gap>| !gapinput@[a,b,c];|
[ 1, 2, 3 ]
\end{Verbatim}
}
\section{\textcolor{Chapter }{Option records for functions}}\label{sec-options}
\logpage{[ 8, 2, 0 ]}
\hyperdef{L}{X7E6207B47B9AA30C}{}
{
\subsection{\textcolor{Chapter }{OptionRecordWithDefaults}}
\logpage{[ 8, 2, 1 ]}\nobreak
\hyperdef{L}{X8322B9377CC590D2}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{OptionRecordWithDefaults({\mdseries\slshape defaults, useroptions})\index{OptionRecordWithDefaults@\texttt{OptionRecordWithDefaults}}
\label{OptionRecordWithDefaults}
}\hfill{\scriptsize (function)}}\\
This functions has been transferred by Chris Jefferson from other packages. It
simplifies the handling of records which are intended to be used for
expressing configuration options. \mbox{\texttt{\mdseries\slshape defaults}} represents the "default record", and \mbox{\texttt{\mdseries\slshape useroptions}} lets the user give new values for values in \mbox{\texttt{\mdseries\slshape defaults}}.
The function returns a record with the same component names as \mbox{\texttt{\mdseries\slshape defaults}} and which has the same values as \mbox{\texttt{\mdseries\slshape defaults}}, except for those component names in \mbox{\texttt{\mdseries\slshape useroptions}}, where the values in \mbox{\texttt{\mdseries\slshape useroptions}} are used instead. An error is given if \mbox{\texttt{\mdseries\slshape useroptions}} contains any component names not in \mbox{\texttt{\mdseries\slshape defaults}}. If \mbox{\texttt{\mdseries\slshape useroptions}} is an empty list it is treated as an empty record, and if \mbox{\texttt{\mdseries\slshape useroptions}} is a list of length $1$ containing a record, this record is used as \mbox{\texttt{\mdseries\slshape useroptions}}.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@defaults := rec( a := 1, b := 2, c := 3 );;|
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, rec( a := 6) );|
rec( a := 6, b := 2, c := 3 )
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, rec( b := 7, c := 8 ) );|
rec( a := 1, b := 7, c := 8 )
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, [ ] );|
rec( a := 1, b := 2, c := 3 )
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, [ rec( c := 8 ) ] );|
rec( a := 1, b := 2, c := 8 )
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, rec( d := 9 ) );|
Error, Unknown option: d
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, [ rec( b := 7 ), rec( c := 8 ) ] );|
Error, Too many arguments for function
!gapprompt@gap>| !gapinput@OptionRecordWithDefaults( defaults, [6,7,8] );|
Error, Too many arguments for function
\end{Verbatim}
This function is designed to support functions with optional arguments given
as a variable record, of the form \texttt{function(x,y,options...)}. In the following, very contrived, example function, \texttt{PrintDimensions}, the defaults are given by the variable \texttt{order} which takes values \texttt{h}, \texttt{w} and \texttt{d} having default values $1$, $2$ and $3$. If there is a second argument, then \texttt{OptionRecordWithDefaults( order, arg[2] );} is used to cvhange the values. These three values then determine the order in
which the three dimensions are printed using a \texttt{SortParallel} command.
\begin{Verbatim}[commandchars=@|A,fontsize=\small,frame=single,label=]
PrintDimensions := function( arg )
local nargs, dim, order, V, L, len, K, i;
nargs := Length( arg );
dim := [ arg[1]!.height, arg[1]!.width, arg[1]!.depth ];
order := rec( h := 1, w := 2, d := 3 );
V := [ "height", "width", "depth" ];
if ( nargs > 1 ) and IsRecord( arg[2] ) then
order := OptionRecordWithDefaults( order, arg[2] );
fi;
L := [ order!.h, order!.w, order!.d ];
len := Length( L );
K := [ 1..len ];
SortParallel( L, K );
Print( "dimensions: " );
Print( V[K[1]], " = ", dim[K[1]], ", " );
Print( V[K[2]], " = ", dim[K[2]], ", " );
Print( V[K[3]], " = ", dim[K[3]], "\n" );
end;;
\end{Verbatim}
In the example below the first call to \texttt{PrintDimensions} has just one parameter, \texttt{mydim}, so the default order is used. In the second call, alternate values for \texttt{h}, \texttt{w} and \texttt{d} are given, causing the width to be printed first, and then the depth and
height.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@mydim := rec( height := 45, width := 31, depth := 17 ); |
rec( depth := 17, height := 45, width := 31 )
!gapprompt@gap>| !gapinput@PrintDimensions( mydim );|
dimensions: height = 45, width = 31, depth = 17
!gapprompt@gap>| !gapinput@PrintDimensions( mydim, rec( h:=3, w:=1, d:=2 ) );|
dimensions: width = 31, depth = 17, height = 45
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Web Downloads}}\label{chap-download}
\logpage{[ 9, 0, 0 ]}
\hyperdef{L}{X815B0C4B7EBE6E1E}{}
{
The \texttt{Download} operation has been written by Thomas Breuer, incorporating a number of
suggestions from Max Horn, for version 0.77 of \textsf{Utils}. It implements downloading a file from within \textsf{GAP}. It can use the \textsf{IO} or \textsf{curlInterface} packages, or \emph{wget} or \emph{curl}, if installed, and it can be extended with other download methods quite
easily. It is envisaged that, once other packages have started to use it, and
any problems have been addressed, that the functions will be transferred to
the main \textsf{GAP} library.
\section{\textcolor{Chapter }{Functions for downloading files from the web}}\label{sec-download}
\logpage{[ 9, 1, 0 ]}
\hyperdef{L}{X8758CB7F79EFB6ED}{}
{
\subsection{\textcolor{Chapter }{Download}}
\logpage{[ 9, 1, 1 ]}\nobreak
\hyperdef{L}{X7A7438AE8448635E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Download({\mdseries\slshape url[, opt]})\index{Download@\texttt{Download}}
\label{Download}
}\hfill{\scriptsize (function)}}\\
This function downloads the file with the web address \mbox{\texttt{\mdseries\slshape url}}, which must be a string.
The result is a record which has at least the component \texttt{success}, with value \texttt{true} if the download was successful and \texttt{false} otherwise. In the former case, the component \texttt{result} is bound, whose value is a string that contains the contents of the downloaded
file. In the latter case, the component \texttt{error} is bound, whose value is a string that describes the problem.
The function calls the methods stored in the global list \texttt{Download{\textunderscore}Methods} until one of them is successful. Currently there are methods based on the \textsf{GAP} functions \texttt{DownloadURL} (\textbf{curl: DownloadURL}) and \texttt{SingleHTTPRequest} (\textbf{IO: SingleHTTPRequest}), and methods based on the external programs \texttt{wget} and \texttt{curl}.
An optional record \mbox{\texttt{\mdseries\slshape opt}} can be given. The following components are supported.
\begin{description}
\item[{\texttt{maxTime}}] If this component is bound then its value must be a nonnegative integer $n$, meaning that the function gives up after $n$ seconds.
A zero value of $n$ means that no timeout is set, the method will never give up in this case.
The default for $n$ is given by the value of the user preference \texttt{DownloadMaxTime} (see \ref{subsec-DownloadMaxTime}).
\item[{\texttt{target}}] If this component is bound then its value must be a string that is a local
filename, and the function writes the downloaded contents to this file; the
returned record does not have a \texttt{result} component in this case.
\item[{\texttt{verifyCert}}] If this component is bound and has the value \texttt{false} then those download methods that are based on \texttt{curl} or \texttt{wget} will omit the check of the server's certificate.
The same effect is achieved for all \texttt{Download} calls by setting the user preference \texttt{DownloadVerifyCertificate} (see \ref{subsec-DownloadVerifyCertificate}) to \texttt{false} and omitting the \texttt{verifyCert} component from \mbox{\texttt{\mdseries\slshape opt}}.
\end{description}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@url:= "https://www.gap-system.org/index.html";;|
!gapprompt@gap>| !gapinput@res1:= Download( url );;|
!gapprompt@gap>| !gapinput@res1.success;|
true
!gapprompt@gap>| !gapinput@IsBound( res1.result ) and IsString( res1.result );|
true
!gapprompt@gap>| !gapinput@res2:= Download( Concatenation( url, "xxx" ) );;|
!gapprompt@gap>| !gapinput@res2.success;|
false
!gapprompt@gap>| !gapinput@IsBound( res2.error ) and IsString( res2.error );|
true
\end{Verbatim}
}
\subsection{\textcolor{Chapter }{User preference \texttt{DownloadVerifyCertificate}}}\label{subsec-DownloadVerifyCertificate}
\logpage{[ 9, 1, 2 ]}
\hyperdef{L}{X85182BA486E3C2AA}{}
{
\index{DownloadVerifyCertificate@\texttt{DownloadVerifyCertificate}} The value \texttt{true} (the default) means that the server's certificate is checked in calls of \texttt{Download} (\ref{Download}), such that nothing gets downloaded if the certificate is invalid.
If the value is \texttt{false} then download methods are supposed to omit the check of the server's
certificate (this may not be supported by all download methods).
One can set the value of the preference to be \texttt{val} via \texttt{SetUserPreference} (\textbf{Reference: SetUserPreference}), by calling \texttt{SetUserPreference( "utils", "DownloadVerifyCertificate", val )}, and access the current value via \texttt{UserPreference} (\textbf{Reference: UserPreference}), by calling \texttt{UserPreference( "utils", "DownloadVerifyCertificate" )}.
We recommend leaving this preference at its default value \texttt{true}. Sometimes it can be necessary to change it, e.g. to work around issues with
old operating systems which may not be able to correctly verify new
certificates. In general it is better to update such a system, but if that is
not an option, then disabling certificate checks may be a good last resort. }
\subsection{\textcolor{Chapter }{User preference \texttt{DownloadMaxTime}}}\label{subsec-DownloadMaxTime}
\logpage{[ 9, 1, 3 ]}
\hyperdef{L}{X79E10E5B83EF929F}{}
{
\index{DownloadMaxTime@\texttt{DownloadMaxTime}} The value \texttt{0} (the default) means that no timeout is set in calls of \texttt{Download} (\ref{Download}). If the value is a positive integer $n$ then those download methods that support a timeout will give up after $n$ seconds.
One can set the value of the preference to be \texttt{val} via \texttt{SetUserPreference} (\textbf{Reference: SetUserPreference}), by calling \texttt{SetUserPreference( "utils", "DownloadMaxTime", val )}, and access the current value via \texttt{UserPreference} (\textbf{Reference: UserPreference}), by calling \texttt{UserPreference( "utils", "DownloadMaxTime" )}. }
}
}
\chapter{\textcolor{Chapter }{Various other functions}}\label{chap-others}
\logpage{[ 10, 0, 0 ]}
\hyperdef{L}{X83EFC3178180D918}{}
{
\section{\textcolor{Chapter }{File operations}}\label{sec-log2html}
\logpage{[ 10, 1, 0 ]}
\hyperdef{L}{X81A0A4FF842B039B}{}
{
\subsection{\textcolor{Chapter }{Log2HTML}}
\logpage{[ 10, 1, 1 ]}\nobreak
\hyperdef{L}{X7B7ECADF85F748BE}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Log2HTML({\mdseries\slshape filename})\index{Log2HTML@\texttt{Log2HTML}}
\label{Log2HTML}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
This function converts the \textsf{GAP} logfile \texttt{filename} to HTML. It appears that the logfile should be in your current directory. The
extension of the input file must be \texttt{*.log}. The name of the output file is the same as the one of the input file except
that the extension \texttt{*.log} is replaced by \texttt{*.html}. There is a sample CSS file in \texttt{utils/doc/gaplog.css}, which you can adjust to your taste.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@LogTo( "triv.log" );|
!gapprompt@gap>| !gapinput@a := 33^5;|
39135393
!gapprompt@gap>| !gapinput@LogTo(); |
!gapprompt@gap>| !gapinput@Log2HTML( "triv.log" ); |
\end{Verbatim}
}
\section{\textcolor{Chapter }{{\LaTeX} strings}}\label{sec-latex}
\logpage{[ 10, 2, 0 ]}
\hyperdef{L}{X84D2922D87EDE9E9}{}
{
\subsection{\textcolor{Chapter }{IntOrOnfinityToLaTeX}}
\logpage{[ 10, 2, 1 ]}\nobreak
\hyperdef{L}{X87DEB2B58266F858}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IntOrOnfinityToLaTeX({\mdseries\slshape n})\index{IntOrOnfinityToLaTeX@\texttt{IntOrOnfinityToLaTeX}}
\label{IntOrOnfinityToLaTeX}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{ResClasses}.
\texttt{IntOrInfinityToLaTeX(n)} returns the {\LaTeX} string for \mbox{\texttt{\mdseries\slshape n}}.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@IntOrInfinityToLaTeX( 10^3 );|
"1000"
!gapprompt@gap>| !gapinput@IntOrInfinityToLaTeX( infinity );|
"\\infty"
\end{Verbatim}
\subsection{\textcolor{Chapter }{LaTeXStringFactorsInt}}
\logpage{[ 10, 2, 2 ]}\nobreak
\hyperdef{L}{X7DC642B97CD02F4E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{LaTeXStringFactorsInt({\mdseries\slshape n})\index{LaTeXStringFactorsInt@\texttt{LaTeXStringFactorsInt}}
\label{LaTeXStringFactorsInt}
}\hfill{\scriptsize (function)}}\\
This function has been transferred from package \textsf{RCWA}.
It returns the prime factorization of the integer $n$ as a string in {\LaTeX} format.
}
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@LaTeXStringFactorsInt( Factorial(12) );|
"2^{10} \\cdot 3^5 \\cdot 5^2 \\cdot 7 \\cdot 11"
\end{Verbatim}
}
\section{\textcolor{Chapter }{Conversion to ${\sf Magma}$ strings}}\label{sec-magma}
\logpage{[ 10, 3, 0 ]}
\hyperdef{L}{X79F021B1830B68F6}{}
{
\subsection{\textcolor{Chapter }{ConvertToMagmaInputString}}
\logpage{[ 10, 3, 1 ]}\nobreak
\hyperdef{L}{X8768D7707B4CBBD4}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertToMagmaInputString({\mdseries\slshape arg})\index{ConvertToMagmaInputString@\texttt{ConvertToMagmaInputString}}
\label{ConvertToMagmaInputString}
}\hfill{\scriptsize (function)}}\\
The function \texttt{ConvertToMagmaInputString( obj [, str] )} attempts to output a string \texttt{s} which can be read into ${\sf Magma}$ \cite{MAGMA} so as to produce the same group in that computer algebra system. In the second
form the user specifies the name of the resulting object, so that the output
string has the form \texttt{"str := ..."}.
When \texttt{obj} is a permutation group, the operation \texttt{PermGroupToMagmaFormat(obj)} is called. \index{PermGroupToMagmaFormat} This function has been taken from \texttt{other.gi} in the main library where it was called \texttt{MagmaInputString}.
When \texttt{obj} is a pc\texttt{\symbol{45}}group, the operation \texttt{PcGroupToMagmaFormat(obj)} is called. \index{PcGroupToMagmaFormat} This function was private code of Max Horn.
When \texttt{obj} is a matrix group over a finite field, the operation \texttt{MatrixGroupToMagmaFormat(obj)} is called. \index{MatrixGroupToMagmaFormat} This function is a modification of private code of Frank L{\"u}beck.
Hopefully code for other types of group will be added in due course.
These functions should be considered \emph{experimental}, and more testing is desirable.
}
\begin{Verbatim}[commandchars=@AB,fontsize=\small,frame=single,label=Example]
@gappromptAgap>B @gapinputA## permutation groupsB
@gappromptAgap>B @gapinputAConvertToMagmaInputString( Group( (1,2,3,4,5), (3,4,5) ) );B
"PermutationGroup<5|(1,2,3,4,5),\n(3,4,5)>;\n"
@gappromptAgap>B @gapinputAConvertToMagmaInputString( Group( (1,2,3,4,5) ), "c5" ); B
"c5 := PermutationGroup<5|(1,2,3,4,5)>;\n"
@gappromptAgap>B @gapinputA## pc-groupB
@gappromptAgap>B @gapinputAConvertToMagmaInputString( DihedralGroup( IsPcGroup, 10 ) );B
"PolycyclicGroup< f1,f2 |\nf1^2,\nf2^5,\nf2^f1 = f2^4\n>;\n"
@gappromptAgap>B @gapinputA## fp-groupB
@gappromptAgap>B @gapinputAF2 := FreeGroup( 2 );;B
@gappromptAgap>B @gapinputAf := F2.1;; g := F2.2;;B
@gappromptAgap>B @gapinputArelq8 := [ f^4, g^4, f*g*f*g^-1, f^2*g^2 ];; B
@gappromptAgap>B @gapinputAq8 := F2/relq8;; B
@gappromptAgap>B @gapinputAConvertToMagmaInputString( q8 );B
no conversion function yet available for fp-groups
fail
@gappromptAgap>B @gapinputA## matrix groupB
@gappromptAgap>B @gapinputAM := GL(2,5);; Size(M); B
480
@gappromptAgap>B @gapinputAs1 := ConvertToMagmaInputString( M );B
"F := GF(5);\nP := GL(2,F);\ngens := [\nP![2,0,0,1],\nP![4,1,4,0]\n];\nsub
;\n"
@gappromptAgap>B @gapinputAPrint( s1 );B
F := GF(5);
P := GL(2,F);
gens := [
P![2,0,0,1],
P![4,1,4,0]
];
sub
;
\end{Verbatim}
}
}
\chapter{\textcolor{Chapter }{Obsolete functions}}\label{chap-obsolete}
\logpage{[ 11, 0, 0 ]}
\hyperdef{L}{X7F561B1D803182FF}{}
{
\section{\textcolor{Chapter }{Operations from AutoDoc}}\label{sec-obs-folders}
\logpage{[ 11, 1, 0 ]}
\hyperdef{L}{X7A6BB3D084912F35}{}
{
The file functions \texttt{FindMatchingFiles} \index{FindMatchingFiles} and \texttt{CreateDirIfMissing} \index{CreateDirIfMissing} were copied from package \textsf{AutoDoc} where they are named \texttt{AutoDoc{\textunderscore}FindMatchingFiles} and \texttt{AutoDoc{\textunderscore}CreateDirIfMissing}.
The string function \texttt{StringDotSuffix} \index{StringDotSuffix} was also copied from package \textsf{AutoDoc}, where it is named \texttt{AUTODOC{\textunderscore}GetSuffix}. \index{GetSuffix}
The function \texttt{SetIfMissing} \index{SetIfMissing} was also transferred from package \textsf{AutoDoc}, where it is called \texttt{AUTODOC{\textunderscore}SetIfMissing}. It writes into a record provided the position is not yet bound.
As from version 0.61, all these functions became obsolete in \textsf{Utils}, but continue to be defined in \textsf{AutoDoc}. }
\section{\textcolor{Chapter }{Functions for printing}}\label{sec-obs-print}
\logpage{[ 11, 2, 0 ]}
\hyperdef{L}{X86F322FC7DECE36F}{}
{
The function \texttt{PrintOneItemPerLine} \index{PrintOneItemPerLine} was used to prints lists vertically, rather than horizontally. Since a very
similar result may be achieved using the \textsf{GAP} library functions \texttt{Perform} and \texttt{Display}, this function became obsolete in version 0.61.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@s3 := SymmetricGroup( 3 );; |
!gapprompt@gap>| !gapinput@L := KnownPropertiesOfObject( GeneratorsOfGroup( s3 ) );;|
!gapprompt@gap>| !gapinput@Perform( L, Display );|
IsFinite
IsSmallList
IsGeneratorsOfMagmaWithInverses
IsGeneratorsOfSemigroup
IsSubsetLocallyFiniteGroup
!gapprompt@gap>| !gapinput@Perform( s3, Display ); |
()
(2,3)
(1,3)
(1,3,2)
(1,2,3)
(1,2)
\end{Verbatim}
}
\section{\textcolor{Chapter }{Other obsolete functions}}\label{sec-obs-others}
\logpage{[ 11, 3, 0 ]}
\hyperdef{L}{X84A4F0B281FA0F94}{}
{
\subsection{\textcolor{Chapter }{Applicable Methods}}\label{subsec-app-meth}
\logpage{[ 11, 3, 1 ]}
\hyperdef{L}{X78B7D1A982BE9866}{}
{
The function \index{PrintApplicableMethod} \texttt{PrintApplicableMethod}, which was included in versions from 0.41 to 0.58, has been removed since it
was considered superfluous. The example shows how to print out a function.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
!gapprompt@gap>| !gapinput@ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 1, 1 );|
#I Searching Method for IsCyclic with 1 arguments:
#I Total: 7 entries
#I Method 4: ``IsCyclic'' at /Applications/gap/gap4r9/lib/grp.gi:30 , value:
36
function( G ) ... end
!gapprompt@gap>| !gapinput@Print( last );|
function ( G )
if Length( GeneratorsOfGroup( G ) ) = 1 then
return true;
else
TryNextMethod();
fi;
return;
end
!gapprompt@gap>| !gapinput@ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 0, 3 );|
function( <1 unnamed arguments> ) ... end
!gapprompt@gap>| !gapinput@Print( last ); |
function ( <> )
<>
end
\end{Verbatim}
}
\subsection{\textcolor{Chapter }{ExponentOfPrime}}\label{subsec-exponent}
\logpage{[ 11, 3, 2 ]}
\hyperdef{L}{X7C1AF2467FB55D79}{}
{
The function \texttt{ExponentOfPrime} \index{ExponentOfPrime} was originally transferred from package \textsf{RCWA}. The command \texttt{ExponentOfPrime(\mbox{\texttt{\mdseries\slshape n}},\mbox{\texttt{\mdseries\slshape p}})} returned the exponent of the prime \mbox{\texttt{\mdseries\slshape p}} in the prime factorization of \mbox{\texttt{\mdseries\slshape n}}.
Since the \textsf{GAP} function \texttt{PValuation} produces the same results, and does so more quickly, this function has been
made obsolete. }
}
}
\chapter{\textcolor{Chapter }{The transfer procedure}}\label{chap-transfer}
\logpage{[ 12, 0, 0 ]}
\hyperdef{L}{X84AC9613842F014C}{}
{
We consider here the process for transferring utility functions from a package \textsf{Home} to \textsf{Utils} which has to avoid the potential problem of duplicate declarations of a
function causing loading problems in \textsf{GAP}.
If the functions in \textsf{Home} all have names of the form \texttt{HOME{\textunderscore}FunctionName} then, in \textsf{Utils}, these functions are likely to be renamed as \texttt{FunctionName} or something similar. In this case the problem of duplicate declarations does
not arise. This is what has happened with transfers from the \textsf{AutoDoc} package.
The case where the function names are unchanged is more complicated. Initially
we tried out a process which allowed repeated declarations and installations
of the functions being transferred. This involved additions to the main
library files \texttt{global.g} and \texttt{oper.g}. Since there were misgivings about interfering in this way with basic
operations such as \texttt{BIND{\textunderscore}GLOBAL}, a simpler (but slightly less convenient) process has been adopted.
Using this alternative procedure, the following steps will be followed when
making transfers from \textsf{Home} to \textsf{Utils}.
\begin{enumerate}
\item (\textsf{Home}:) Offer functions for inclusion. This may be simply done by emailing a list
of functions. More usefully, email the declaration, implementation, test and
documentation files, e.g.: \texttt{home.gd}, \texttt{home.gi}, \texttt{home.tst} and \texttt{home.xml}. (All active authors should be involved.)
\item (\textsf{Home}:) Declare that \textsc{m.n} is the last version of \textsf{Home} to contain these functions, so that \textsc{m.n+1} (or similar) will be the first version of \textsf{Home} to have all these functions removed, and to specify \textsf{Utils} as a required package.
\item (\textsf{Utils}:) Add strings \mbox{\texttt{\mdseries\slshape "home"}} and \mbox{\texttt{\mdseries\slshape "m.n"}} to the list \texttt{UtilsPackageVersions} in the file \texttt{utils/lib/start.gd}.
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
UtilsPackageVersions :=
[ "autodoc", "2016.01.31",
"resclasses", "4.2.5",
"home", "m.n",
..., ...
];
\end{Verbatim}
While the transfers are being made, it is essential that any new versions of \textsf{Home} should be tested with the latest version of \textsf{Utils} before they are released, so as to avoid loading failures.
\item (\textsf{Utils}:) Include the function declaration and implementation sections in suitable
files, enclosed within a conditional clause of the form:
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
if OKtoReadFromUtils( "Home" ) then
. . . . . .
. . . . . .
fi;
\end{Verbatim}
\index{OKtoReadFromUtils} The function \texttt{OKtoReadFromUtils} returns \texttt{true} only if there is an installed version of \textsf{Home} and if this version is greater than \textsc{m.n}. So, at this stage, \emph{the copied code will not be read}, and the transferred functions can only be called if \textsf{Home} has been installed.
\item (\textsf{Utils}:) Add the test and documentation material to the appropriate files. The
copied code can be tested by temporarily moving \textsf{Home} away from \textsf{GAP}'s package directory.
\item (\textsf{Utils}:) Release a new version of \textsf{Utils} containing all the transferred material.
\item (\textsf{Home}:) Edit out the declarations and implementations of all the transferred
functions, and remove references to them in the manual and tests. Possibly add
a note to the manual that these functions have been transferred. Add \textsf{Utils} to the list of \textsf{Home}'s required packages in \texttt{PackageInfo.g}. Release a new version of \textsf{Home}.
\item (\textsf{Utils}:) In due course, when the new version(s) of \textsf{Home} are well established, it may be safe to remove the conditional clauses
mentioned in item 4 above. The entry for \textsf{Home} in \texttt{UtilsPackageLists} may then be removed.
\end{enumerate}
Finally, a note on the procedure for testing these functions. As long as a
function being transferred still exists in the \textsf{Home} package, the code will not be read from \textsf{Utils}. So, when the tests are run, it is necessary to \texttt{LoadPackage("home")} before the function is called. The file \texttt{utils/tst/testall.g} makes sure that all the necessary packages are loaded before the individual
tests are called. }
\def\bibname{References\logpage{[ "Bib", 0, 0 ]}
\hyperdef{L}{X7A6F98FD85F02BFE}{}
}
\bibliographystyle{alpha}
\bibliography{bib.xml}
\addcontentsline{toc}{chapter}{References}
\def\indexname{Index\logpage{[ "Ind", 0, 0 ]}
\hyperdef{L}{X83A0356F839C696F}{}
}
\cleardoublepage
\phantomsection
\addcontentsline{toc}{chapter}{Index}
\printindex
\immediate\write\pagenrlog{["Ind", 0, 0], \arabic{page},}
\newpage
\immediate\write\pagenrlog{["End"], \arabic{page}];}
\immediate\closeout\pagenrlog
\end{document}
utils-0.93/doc/rainbow.js 0000644 0001751 0001751 00000005336 15105376105 014771 0 ustar runner runner
function randchar(str) {
var i = Math.floor(Math.random() * str.length);
while (i == str.length)
i = Math.floor(Math.random() * str.length);
return str[i];
}
hexdigits = "0123456789abcdef";
function randlight() {
return randchar("cdef")+randchar(hexdigits)+
randchar("cdef")+randchar(hexdigits)+
randchar("cdef")+randchar(hexdigits)
}
function randdark() {
return randchar("012345789")+randchar(hexdigits)+
randchar("012345789")+randchar(hexdigits)+
randchar("102345789")+randchar(hexdigits)
}
document.write('\n');
utils-0.93/doc/nocolorprompt.css 0000644 0001751 0001751 00000000313 15105376105 016407 0 ustar runner runner
/* colors for ColorPrompt like examples */
span.GAPprompt {
color: #000000;
font-weight: normal;
}
span.GAPbrkprompt {
color: #000000;
font-weight: normal;
}
span.GAPinput {
color: #000000;
}
utils-0.93/doc/chap1_mj.html 0000644 0001751 0001751 00000021360 15105376105 015335 0 ustar runner runner
GAP (Utils) - Chapter 1: Introduction
The Utils package provides a space for utility functions from a variety of GAP packages to be collected together into a single package. In this way it is hoped that they will become more visible to other package authors. This package was first distributed as part of the GAP 4.8.2 distribution.
The package is loaded with the command
gap>LoadPackage( "utils" );
Functions have been transferred from the following packages:
Conversion of a GAP group to a \({\sf Magma}\) output string, taken from various sources including other.gi in the main library.
Transfer is complete (for now) for functions from the following packages:
Once the package is loaded, the manual doc/manual.pdf can be found in the documentation folder. The html versions, with or without \({\sf MathJax}\), may be rebuilt as follows:
gap>ReadPackage( "utils", "makedoc.g" );
It is possible to check that the package has been installed correctly by running the test files (which terminates the GAP session):
Note that functions listed in this manual that are currently in the process of being transferred are only read from the source package Home (say), and so can only be used if Home has already been loaded. There are no such functions in transition at present.
1.1 Information for package authors
A function (or collection of functions) is suitable for transfer from a package Home to Utils if the following conditions are satisfied.
The function is sufficiently non-specialised so that it might be of use to other authors.
The function does not depend on the remaining functions in Home
The function does not do what can already be done with a GAP library function.
Documentation of the function and test examples are available.
When there is more than one active author of Home, they should all be aware (and content) that the transfer is taking place.
Authors of packages may be reluctant to let go of their utility functions. The following principles may help to reassure them. (Suggestions for more items here are welcome.)
A function that has been transferred to Utils will not be changed without the approval of the original author.
The current package maintainer has every intention of continuing to maintain Utils. In the event that this proves impossible, the GAP development team will surely find someone to take over.
Function names will not be changed unless specifically requested by Home's author(s) or unless they have the form HOME_FunctionName.
In order to speed up the transfer process, only functions from one package will be in transition at any given time. Hopefully a week or two will suffice for most packages.
Any package author who transfers a function to Utils will become an author of Utils. (In truth, Utils does not have authors, just a large number of contributors.)
The process for transferring utility functions from Home to Utils is described in Chapter 12.
This function has been transferred from package RCWA.
This function converts the GAP logfile filename to HTML. It appears that the logfile should be in your current directory. The extension of the input file must be *.log. The name of the output file is the same as the one of the input file except that the extension *.log is replaced by *.html. There is a sample CSS file in utils/doc/gaplog.css, which you can adjust to your taste.
The function ConvertToMagmaInputString( obj [, str] ) attempts to output a string s which can be read into \({\sf Magma}\)[BCP97] so as to produce the same group in that computer algebra system. In the second form the user specifies the name of the resulting object, so that the output string has the form "str := ...".
When obj is a permutation group, the operation PermGroupToMagmaFormat(obj) is called. This function has been taken from other.gi in the main library where it was called MagmaInputString.
When obj is a pc-group, the operation PcGroupToMagmaFormat(obj) is called. This function was private code of Max Horn.
When obj is a matrix group over a finite field, the operation MatrixGroupToMagmaFormat(obj) is called. This function is a modification of private code of Frank LĂĽbeck.
Hopefully code for other types of group will be added in due course.
These functions should be considered experimental, and more testing is desirable.
In June 2023 Hongyi Zhao asked in the Forum for a function to implement matrix decomposition into blocks. Such a function was then provided by Pedro GarcĂa-Sánchez. Hongyi Zhao then requested that the function be added to Utils. What is provided here is a revised version of the original solution, returning a list of decompositions.
This function is a partial inverse to the undocumented library operation DirectSumMat. So if \(L\) is the list of diagonal decompositions of a matrix \(M\) then each entry in \(L\) is a list of matrices, and the direct sum of each of these lists is equal to the original \(M\).
In the following examples, \(M_6\) is an obvious direct sum with \(3\) blocks. \(M_4\) is an example with three decompositions, while \(M_8 = M_4 \oplus M_4\) has \(16\) decompositions (not listed).
The current method does not, however, catch all possible decompositions. In the following example the matrix \(M_5\) has its third row and third column extirely zero, and the only decomposition found has a \([0]\) factor. There are clearly two \(2\)-factor decompositions with a \(2\)-by-\(3\) and a \(3\)-by-\(2\) factor, but these are not found at present.
utils-0.93/doc/chap5.txt 0000644 0001751 0001751 00000057730 15105376105 014540 0 ustar runner runner
[1X5 [33X[0;0YGroups and homomorphisms[133X[101X
[1X5.1 [33X[0;0YFunctions for groups[133X[101X
[1X5.1-1 Comm[101X
[33X[1;0Y[29X[2XComm[102X( [3XL[103X ) [32X operation[133X
[33X[0;0YThis method has been transferred from package [5XResClasses[105X.[133X
[33X[0;0YIt provides a method for [10XComm[110X when the argument is a list (enclosed in
square brackets), and calls the function [10XLeftNormedComm[110X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XComm( [ (1,2), (2,3) ] );[127X[104X
[4X[28X(1,2,3)[128X[104X
[4X[25Xgap>[125X [27XComm( [(1,2),(2,3),(3,4),(4,5),(5,6)] );[127X[104X
[4X[28X(1,5,6)[128X[104X
[4X[25Xgap>[125X [27XComm(Comm(Comm(Comm((1,2),(2,3)),(3,4)),(4,5)),(5,6)); ## the same[127X[104X
[4X[28X(1,5,6)[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.1-2 IsCommuting[101X
[33X[1;0Y[29X[2XIsCommuting[102X( [3Xa[103X, [3Xb[103X ) [32X operation[133X
[33X[0;0YThis function has been transferred from package [5XResClasses[105X.[133X
[33X[0;0YIt tests whether two elements in a group commute.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XD12 := DihedralGroup( 12 );[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XSetName( D12, "D12" ); [127X[104X
[4X[25Xgap>[125X [27Xa := D12.1;; b := D12.2;; [127X[104X
[4X[25Xgap>[125X [27XIsCommuting( a, b );[127X[104X
[4X[28Xfalse[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.1-3 ListOfPowers[101X
[33X[1;0Y[29X[2XListOfPowers[102X( [3Xg[103X, [3Xexp[103X ) [32X operation[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThe operation [10XListOfPowers(g,exp)[110X returns the list [22X[g,g^2,...,g^exp][122X of
powers of the element [22Xg[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XListOfPowers( 2, 20 );[127X[104X
[4X[28X[ 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384,[128X[104X
[4X[28X 32768, 65536, 131072, 262144, 524288, 1048576 ][128X[104X
[4X[25Xgap>[125X [27XListOfPowers( (1,2,3)(4,5), 12 );[127X[104X
[4X[28X[ (1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5), (),[128X[104X
[4X[28X (1,2,3)(4,5), (1,3,2), (4,5), (1,2,3), (1,3,2)(4,5), () ][128X[104X
[4X[25Xgap>[125X [27XListOfPowers( D12.2, 6 );[127X[104X
[4X[28X[ f2, f3, f2*f3, f3^2, f2*f3^2, of ... ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.1-4 GeneratorsAndInverses[101X
[33X[1;0Y[29X[2XGeneratorsAndInverses[102X( [3XG[103X ) [32X operation[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThis operation returns a list containing the generators of [22XG[122X followed by the
inverses of these generators.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XGeneratorsAndInverses( D12 );[127X[104X
[4X[28X[ f1, f2, f3, f1, f2*f3^2, f3^2 ][128X[104X
[4X[25Xgap>[125X [27XGeneratorsAndInverses( SymmetricGroup(5) ); [127X[104X
[4X[28X[ (1,2,3,4,5), (1,2), (1,5,4,3,2), (1,2) ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.1-5 UpperFittingSeries[101X
[33X[1;0Y[29X[2XUpperFittingSeries[102X( [3XG[103X ) [32X attribute[133X
[33X[1;0Y[29X[2XLowerFittingSeries[102X( [3XG[103X ) [32X attribute[133X
[33X[1;0Y[29X[2XFittingLength[102X( [3XG[103X ) [32X attribute[133X
[33X[0;0YThese three functions have been transferred from package [5XResClasses[105X.[133X
[33X[0;0YThe upper and lower Fitting series and the Fitting length of a solvable
group are described here: [7Xhttps://en.wikipedia.org/wiki/Fitting_length[107X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XUpperFittingSeries( D12 ); LowerFittingSeries( D12 );[127X[104X
[4X[28X[ Group([ ]), Group([ f3, f2*f3 ]), Group([ f1, f3, f2*f3 ]) ][128X[104X
[4X[28X[ D12, Group([ f3 ]), Group([ ]) ][128X[104X
[4X[25Xgap>[125X [27XFittingLength( D12 );[127X[104X
[4X[28X2[128X[104X
[4X[25Xgap>[125X [27XS4 := SymmetricGroup( 4 );;[127X[104X
[4X[25Xgap>[125X [27XUpperFittingSeries( S4 );[127X[104X
[4X[28X[ Group(()), Group([ (1,2)(3,4), (1,4)(2,3) ]), Group([ (1,2)(3,4), (1,4)[128X[104X
[4X[28X (2,3), (2,4,3) ]), Group([ (3,4), (2,3,4), (1,2)(3,4) ]) ][128X[104X
[4X[25Xgap>[125X [27XList( last, StructureDescription );[127X[104X
[4X[28X[ "1", "C2 x C2", "A4", "S4" ][128X[104X
[4X[25Xgap>[125X [27XLowerFittingSeries( S4 );[127X[104X
[4X[28X[ Sym( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), Group([ (1,4)(2,3), (1,3)[128X[104X
[4X[28X (2,4) ]), Group(()) ][128X[104X
[4X[25Xgap>[125X [27XList( last, StructureDescription );[127X[104X
[4X[28X[ "S4", "A4", "C2 x C2", "1" ][128X[104X
[4X[25Xgap>[125X [27XFittingLength( S4);[127X[104X
[4X[28X3[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.2 [33X[0;0YLeft Cosets for Groups[133X[101X
[1X5.2-1 LeftCoset[101X
[33X[1;0Y[29X[2XLeftCoset[102X( [3Xg[103X, [3XU[103X ) [32X operation[133X
[33X[0;0YSince [5XGAP[105X uses right actions by default, the library contains the operation
[10XRightCoset(U,g)[110X for constructing the right coset [22XUg[122X of a subgroup [22XU ≤ G[122X and
an element [22Xg â G[122X. It has been noted in the reference manual that, by
inverting all the elements in [22XUg[122X, the left coset [22Xg^-1U[122X is obtained.[133X
[33X[0;0YJust for the sake of completeness, from August 2022 this package provides
the operation [10XLeftCoset(g,U)[110X for constructing the left coset [22XgU[122X. Users are
strongly recommended to continue to use [10XRightCoset[110X for all serious
calculations, since left cosets have a much simpler implementation and do
not behave exactly like right cosets.[133X
[33X[0;0YThe methods for left cosets which are provided generally work by converting
[22XgU[122X to [22XUg^-1[122X; applying the equivalent method for right cosets; and, if
necessary, converting back again to left cosets.[133X
[33X[0;0Y[22XG[122X acts on left cosets by [10XOnLeftInverse[110X: [22X(gU)^g_0 = g_0^-1*(gU) = (g_0^-1g)U[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xa4 := Group( (1,2,3), (2,3,4) );; SetName( a4, "a4" );[127X[104X
[4X[25Xgap>[125X [27Xk4 := Group( (1,2)(3,4), (1,3)(2,4) );; SetName( k4, "k4" );[127X[104X
[4X[25Xgap>[125X [27Xrc := RightCosets( a4, k4 );[127X[104X
[4X[28X[ RightCoset(k4,()), RightCoset(k4,(2,3,4)), RightCoset(k4,(2,4,3)) ][128X[104X
[4X[25Xgap>[125X [27Xlc := LeftCosets( a4, k4 );[127X[104X
[4X[28X[ LeftCoset((),k4), LeftCoset((2,4,3),k4), LeftCoset((2,3,4),k4) ][128X[104X
[4X[25Xgap>[125X [27XAsSet( lc[2] );[127X[104X
[4X[28X[ (2,4,3), (1,2,3), (1,3,4), (1,4,2) ][128X[104X
[4X[25Xgap>[125X [27XLeftCoset( (1,4,2), k4 ) = lc[2];[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27XRepresentative( lc[2] );[127X[104X
[4X[28X(2,4,3)[128X[104X
[4X[25Xgap>[125X [27XActingDomain( lc[2] );[127X[104X
[4X[28Xk4[128X[104X
[4X[25Xgap>[125X [27X(1,4,3) in lc[3];[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27X(1,2,3)*lc[2] = lc[3];[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27Xlc[2]^(1,3,2) = lc[3];[127X[104X
[4X[28Xtrue[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.2-2 [33X[0;0YInverse[133X[101X
[33X[0;0YThe inverse of the left coset [22XgU[122X is the right coset [22XUg^-1[122X, and conversely.
This is an abuse of the attribute [10XInverse[110X, since the standard requirement,
that [22Xx*x^-1[122X is an identity, does not hold.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XInverse( rc[3] ) = lc[3];[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27XInverse( lc[2] ) = rc[2];[127X[104X
[4X[28Xtrue[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.3 [33X[0;0YFunctions for group homomorphisms[133X[101X
[1X5.3-1 EpimorphismByGenerators[101X
[33X[1;0Y[29X[2XEpimorphismByGenerators[102X( [3XG[103X, [3XH[103X ) [32X operation[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YIt constructs a group homomorphism which maps the generators of [22XG[122X to those
of [22XH[122X. Its intended use is when [22XG[122X is a free group, and a warning is printed
when this is not the case. Note that anything may happen if the resulting
map is not a homomorphism![133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XG := Group( (1,2,3), (3,4,5), (5,6,7), (7,8,9) );;[127X[104X
[4X[25Xgap>[125X [27Xphi := EpimorphismByGenerators( FreeGroup("a","b","c","d"), G );[127X[104X
[4X[28X[ a, b, c, d ] -> [ (1,2,3), (3,4,5), (5,6,7), (7,8,9) ][128X[104X
[4X[25Xgap>[125X [27XPreImagesRepresentativeNC( phi, (1,2,3,4,5,6,7,8,9) );[127X[104X
[4X[28Xd*c*b*a[128X[104X
[4X[25Xgap>[125X [27Xa := G.1;; b := G.2;; c := G.3;; d := G.4;;[127X[104X
[4X[25Xgap>[125X [27Xd*c*b*a;[127X[104X
[4X[28X(1,2,3,4,5,6,7,8,9)[128X[104X
[4X[25Xgap>[125X [27X## note that it is easy to produce nonsense: [127X[104X
[4X[25Xgap>[125X [27Xepi := EpimorphismByGenerators( Group((1,2,3)), Group((8,9)) );[127X[104X
[4X[28XWarning: calling GroupHomomorphismByImagesNC without checks[128X[104X
[4X[28X[ (1,2,3) ] -> [ (8,9) ][128X[104X
[4X[25Xgap>[125X [27XIsGroupHomomorphism( epi );[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27XImage( epi, (1,2,3) ); [127X[104X
[4X[28X()[128X[104X
[4X[25Xgap>[125X [27XImage( epi, (1,3,2) );[127X[104X
[4X[28X(8,9)[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.3-2 Pullback[101X
[33X[1;0Y[29X[2XPullback[102X( [3Xhom1[103X, [3Xhom2[103X ) [32X operation[133X
[33X[1;0Y[29X[2XPullbackInfo[102X( [3XG[103X ) [32X attribute[133X
[33X[0;0YIf [22XĎ•_1 : G_1 -> H[122X and [22XĎ•_2 : G_2 -> H[122X are two group homomorphisms with the
same range, then their [13Xpullback[113X is the subgroup of [22XG_1 Ă— G_2[122X consisting of
those elements [22X(g_1,g_2)[122X such that [22XĎ•_1 g_1 = Ď•_2 g_2[122X.[133X
[33X[0;0YThe attribute [10XPullbackInfo[110X of a pullback group [10XP[110X is similar to
[10XDirectProductInfo[110X for a direct product of groups. Its value is a record with
the following components:[133X
[8X[10XdirectProduct[110X[8X[108X
[33X[0;6Ythe direct product [22XG_1 Ă— G_2[122X, and[133X
[8X[10Xprojections[110X[8X[108X
[33X[0;6Ya list with the two projections onto [22XG_1[122X and [22XG_2[122X.[133X
[33X[0;0YThere are no embeddings in this record, but it is possible to use the
embeddings into the direct product, see [2XEmbedding[102X ([14XReference: Embedding[114X).[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xs4 := Group( (1,2),(2,3),(3,4) );;[127X[104X
[4X[25Xgap>[125X [27Xs3 := Group( (5,6),(6,7) );;[127X[104X
[4X[25Xgap>[125X [27Xc3 := Subgroup( s3, [ (5,6,7) ] );;[127X[104X
[4X[25Xgap>[125X [27Xf := GroupHomomorphismByImages( s4, s3, [127X[104X
[4X[25X>[125X [27X [(1,2),(2,3),(3,4)], [(5,6),(6,7),(5,6)] );; [127X[104X
[4X[25Xgap>[125X [27Xi := GroupHomomorphismByImages( c3, s3, [(5,6,7)], [(5,6,7)] );; [127X[104X
[4X[25Xgap>[125X [27XPfi := Pullback( f, i );[127X[104X
[4X[28XGroup([ (2,3,4)(5,7,6), (1,2)(3,4) ])[128X[104X
[4X[25Xgap>[125X [27XStructureDescription( Pfi );[127X[104X
[4X[28X"A4"[128X[104X
[4X[25Xgap>[125X [27Xinfo := PullbackInfo( Pfi );[127X[104X
[4X[28Xrec( directProduct := Group([ (1,2), (2,3), (3,4), (5,6,7) ]), [128X[104X
[4X[28X projections := [ [ (2,3,4)(5,7,6), (1,2)(3,4) ] -> [ (2,3,4), (1,2)(3,4) ], [128X[104X
[4X[28X [ (2,3,4)(5,7,6), (1,2)(3,4) ] -> [ (5,7,6), () ] ] )[128X[104X
[4X[25Xgap>[125X [27Xg := (1,2,3)(5,6,7);; [127X[104X
[4X[25Xgap>[125X [27XImageElm( info!.projections[1], g );[127X[104X
[4X[28X(1,2,3)[128X[104X
[4X[25Xgap>[125X [27XImageElm( info!.projections[2], g );[127X[104X
[4X[28X(5,6,7) [128X[104X
[4X[25Xgap>[125X [27Xdp := info!.directProduct;; [127X[104X
[4X[25Xgap>[125X [27Xa := ImageElm( Embedding( dp, 1 ), (1,4,3) );; [127X[104X
[4X[25Xgap>[125X [27Xb := ImageElm( Embedding( dp, 2 ), (5,7,6) );; [127X[104X
[4X[25Xgap>[125X [27Xa*b in Pfi;[127X[104X
[4X[28Xtrue[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.3-3 CentralProduct[101X
[33X[1;0Y[29X[2XCentralProduct[102X( [3XG1[103X, [3XG2[103X, [3XZ1[103X, [3XPhi[103X ) [32X operation[133X
[33X[1;0Y[29X[2XCentralProductInfo[102X( [3XG[103X ) [32X attribute[133X
[33X[0;0YThis function was added by Thomas Breuer, following discussions with Hongyi
Zhao (see [7Xhttps://github.com/gap-packages/hap/issues/73[107X).[133X
[33X[0;0YLet [3XG1[103X and [3XG2[103X be two groups, [3XZ1[103X be a central subgroup of [3XG1[103X, and [3XPhi[103X be an
isomorphism from [3XZ1[103X to a central subgroup of [3XG2[103X. The [13Xcentral product[113X defined
by these arguments is the factor group of the direct product of [3XG1[103X and [3XG2[103X by
the central subgroup [22X{ (z, ([3XPhi[103X(z))^-1) : z â [3XZ1[103X }[122X.[133X
[33X[0;0YThe attribute [2XCentralProductInfo[102X of a group [22XG[122X that has been created by
[2XCentralProduct[102X is similar to [2XPullbackInfo[102X ([14X5.3-2[114X) for pullback groups. Its
value is a record with the following components.[133X
[8X[10Xprojection[110X[8X[108X
[33X[0;6Ythe epimorphism from the direct product of [3XG1[103X and [3XG2[103X to [22XG[122X, and[133X
[8X[10Xphi[110X[8X[108X
[33X[0;6Ythe map [3XPhi[103X.[133X
[33X[0;0YNote that one can access the direct product as the [2XSource[102X ([14XReference:
Source[114X) value of the [10Xprojection[110X map, and one can access [3XG1[103X and [3XG2[103X as the two
embeddings of this direct product, see [2XEmbedding[102X ([14XReference: Embedding[114X).[133X
[4X[32X Example [32X[104X
[4X[25Xgap>[125X [27Xg1 := DihedralGroup( 8 );[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xc1 := Centre( g1 );[127X[104X
[4X[28XGroup([ f3 ])[128X[104X
[4X[25Xgap>[125X [27Xcp1 := CentralProduct( g1, g1, c1, IdentityMapping( c1 ) );[127X[104X
[4X[28XGroup([ f1, f2, f5, f3, f4, f5 ])[128X[104X
[4X[25Xgap>[125X [27XIdGroup( cp1 ) = IdGroup( ExtraspecialGroup( 2^5, "+" ) );[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27Xg2 := QuaternionGroup( 8 );[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xc2 := Centre( g2 );[127X[104X
[4X[28XGroup([ y2 ])[128X[104X
[4X[25Xgap>[125X [27Xcp2 := CentralProduct( g2, g2, c2, IdentityMapping( c2 ) );[127X[104X
[4X[28XGroup([ f1, f2, f5, f3, f4, f5 ])[128X[104X
[4X[25Xgap>[125X [27XIdGroup( cp2 ) = IdGroup( ExtraspecialGroup( 2^5, "+" ) );[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27Xinfo2 := CentralProductInfo( cp2 );[127X[104X
[4X[28Xrec( phi := IdentityMapping( Group([ y2 ]) ), [128X[104X
[4X[28X projection := [ f1, f2, f3, f4, f5, f6 ] -> [ f1, f2, f5, f3, f4, f5 ] )[128X[104X
[4X[25Xgap>[125X [27XSource( Embedding( Source( info2.projection ), 1 ) ) = g2;[127X[104X
[4X[28Xtrue[128X[104X
[4X[32X[104X
[1X5.3-4 IdempotentEndomorphisms[101X
[33X[1;0Y[29X[2XIdempotentEndomorphisms[102X( [3XG[103X ) [32X operation[133X
[33X[1;0Y[29X[2XIdempotentEndomorphismsData[102X( [3XG[103X ) [32X attribute[133X
[33X[1;0Y[29X[2XIdempotentEndomorphismsWithImage[102X( [3XgenG[103X, [3XR[103X ) [32X operation[133X
[33X[0;0YAn endomorphism [22Xf : G -> G[122X is idempotent if [22Xf^2=f[122X. It has an image [22XR
leqslant G[122X; is the identity map when restricted to [22XR[122X; and has a kernel [22XN[122X
which has trivial intersection with [22XR[122X and has size [22X|G|/|R|[122X.[133X
[33X[0;0YThe operation [10XIdempotentEndomorphismsWithImage(genG,R)[110X returns a list of the
images of the generating set [10XgenG[110X of a group [22XG[122X under the idempotent
endomorphisms with image [22XR[122X.[133X
[33X[0;0YThe attribute [10XIdempotentEndomorphismsData(G)[110X returns a record [10Xdata[110X with
fields [10Xdata.gens[110X, a fixed generating set for [22XG[122X, and [10Xdata.images[110X a list of
the non-empty outputs of [10XIdempotentEndomorphismsWithImage(genG,R)[110X obtained
by iterating over all subgroups of [22XG[122X.[133X
[33X[0;0YThe operation [10XIdempotentEndomorphisms(G)[110X returns the list of these mappings
obtained using [10XIdempotentEndomorphismsData(G)[110X. The first of these is the
zero map, the second is the identity.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xgens := [ (1,2,3,4), (1,2)(3,4) ];; [127X[104X
[4X[25Xgap>[125X [27Xd8 := Group( gens );;[127X[104X
[4X[25Xgap>[125X [27XSetName( d8, "d8" );[127X[104X
[4X[25Xgap>[125X [27Xc2 := Subgroup( d8, [ (2,4) ] );;[127X[104X
[4X[25Xgap>[125X [27XIdempotentEndomorphismsWithImage( gens, c2 );[127X[104X
[4X[28X[ [ (), (2,4) ], [ (2,4), () ] ][128X[104X
[4X[25Xgap>[125X [27XIdempotentEndomorphismsData( d8 );[127X[104X
[4X[28Xrec( gens := [ (1,2,3,4), (1,2)(3,4) ], [128X[104X
[4X[28X images := [ [ [ (), () ] ], [ [ (), (2,4) ], [ (2,4), () ] ], [128X[104X
[4X[28X [ [ (), (1,3) ], [ (1,3), () ] ], [128X[104X
[4X[28X [ [ (), (1,2)(3,4) ], [ (1,2)(3,4), (1,2)(3,4) ] ], [128X[104X
[4X[28X [ [ (), (1,4)(2,3) ], [ (1,4)(2,3), (1,4)(2,3) ] ], [128X[104X
[4X[28X [ [ (1,2,3,4), (1,2)(3,4) ] ] ] )[128X[104X
[4X[25Xgap>[125X [27XList( last.images, L -> Length(L) );[127X[104X
[4X[28X[ 1, 2, 2, 2, 2, 1 ][128X[104X
[4X[25Xgap>[125X [27XIdempotentEndomorphisms( d8 ); [127X[104X
[4X[28X[ [ (1,2,3,4), (1,2)(3,4) ] -> [ (), () ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (), (2,4) ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (2,4), () ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,3) ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (1,3), () ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,2)(3,4) ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (1,2)(3,4), (1,2)(3,4) ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (), (1,4)(2,3) ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (1,4)(2,3), (1,4)(2,3) ], [128X[104X
[4X[28X [ (1,2,3,4), (1,2)(3,4) ] -> [ (1,2,3,4), (1,2)(3,4) ] ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[33X[0;0YThe quaternion group [10Xq8[110X is an example of a group with a tail: there is only
one subgroup in the lattice which covers the identity subgroup. The only
idempotent isomorphisms of such groups are the identity mapping and the zero
mapping because the only pairs [22XN,R[122X are the whole group and the identity
subgroup.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xq8 := QuaternionGroup( 8 );;[127X[104X
[4X[25Xgap>[125X [27XIdempotentEndomorphisms( q8 );[127X[104X
[4X[28X[ [ x, y ] -> [ of ..., of ... ], [ x, y ] -> [ x, y ] ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.3-5 DirectProductOfFunctions[101X
[33X[1;0Y[29X[2XDirectProductOfFunctions[102X( [3XG[103X, [3XH[103X, [3Xf1[103X, [3Xf2[103X ) [32X operation[133X
[33X[0;0YGiven group homomorphisms [22Xf_1 : G_1 -> G_2[122X and [22Xf_2 : H_1 -> H_2[122X, this
operation return the product homomorphism [22Xf_1 Ă— f_2 : G_1 Ă— G_2 -> H_1 Ă—
H_2[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xc4 := Group( (1,2,3,4) );; [127X[104X
[4X[25Xgap>[125X [27Xc2 := Group( (5,6) );; [127X[104X
[4X[25Xgap>[125X [27Xf1 := GroupHomomorphismByImages( c4, c2, [(1,2,3,4)], [(5,6)] );;[127X[104X
[4X[25Xgap>[125X [27Xc3 := Group( (1,2,3) );; [127X[104X
[4X[25Xgap>[125X [27Xc6 := Group( (1,2,3,4,5,6) );; [127X[104X
[4X[25Xgap>[125X [27Xf2 := GroupHomomorphismByImages( c3, c6, [(1,2,3)], [(1,3,5)(2,4,6)] );; [127X[104X
[4X[25Xgap>[125X [27Xc4c3 := DirectProduct( c4, c3 ); [127X[104X
[4X[28XGroup([ (1,2,3,4), (5,6,7) ])[128X[104X
[4X[25Xgap>[125X [27Xc2c6 := DirectProduct( c2, c6 ); [127X[104X
[4X[28XGroup([ (1,2), (3,4,5,6,7,8) ])[128X[104X
[4X[25Xgap>[125X [27Xf := DirectProductOfFunctions( c4c3, c2c6, f1, f2 ); [127X[104X
[4X[28X[ (1,2,3,4), (5,6,7) ] -> [ (1,2), (3,5,7)(4,6,8) ][128X[104X
[4X[25Xgap>[125X [27XImageElm( f, (1,4,3,2)(5,7,6) ); [127X[104X
[4X[28X(1,2)(3,7,5)(4,8,6)[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X5.3-6 DirectProductOfAutomorphismGroups[101X
[33X[1;0Y[29X[2XDirectProductOfAutomorphismGroups[102X( [3XA1[103X, [3XA2[103X ) [32X operation[133X
[33X[0;0YLet [22XA_1,A_2[122X be groups of automorphism of groups [22XG_1,G_2[122X respectively. The
output of this function is a group [22XA_1 Ă— A_2[122X of automorphisms of [22XG_1 Ă— G_2[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xc9 := Group( (1,2,3,4,5,6,7,8,9) );; [127X[104X
[4X[25Xgap>[125X [27Xac9 := AutomorphismGroup( c9 );; [127X[104X
[4X[25Xgap>[125X [27Xq8 := QuaternionGroup( IsPermGroup, 8 );;[127X[104X
[4X[25Xgap>[125X [27Xaq8 := AutomorphismGroup( q8 );;[127X[104X
[4X[25Xgap>[125X [27XA := DirectProductOfAutomorphismGroups( ac9, aq8 );[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XgenA := GeneratorsOfGroup( A );;[127X[104X
[4X[25Xgap>[125X [27XG := Source( genA[1] );[127X[104X
[4X[28XGroup([ (1,2,3,4,5,6,7,8,9), (10,14,12,16)(11,17,13,15), (10,11,12,13)[128X[104X
[4X[28X(14,15,16,17) ])[128X[104X
[4X[25Xgap>[125X [27Xa := genA[1]*genA[5]; [127X[104X
[4X[28X[ (1,2,3,4,5,6,7,8,9), (10,14,12,16)(11,17,13,15), (10,11,12,13)(14,15,16,17) [128X[104X
[4X[28X ] -> [ (1,3,5,7,9,2,4,6,8), (10,16,12,14)(11,15,13,17), [128X[104X
[4X[28X (10,11,12,13)(14,15,16,17) ][128X[104X
[4X[25Xgap>[125X [27XImageElm( a, (1,9,8,7,6,5,4,3,2)(10,14,12,16)(11,17,13,15) );[127X[104X
[4X[28X(1,8,6,4,2,9,7,5,3)(10,16,12,14)(11,15,13,17)[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
utils-0.93/doc/obsolete.xml 0000644 0001751 0001751 00000007627 15105376105 015335 0 ustar runner runner
Obsolete functionsOperations from AutoDoc
The file functions FindMatchingFilesFindMatchingFiles
and CreateDirIfMissingCreateDirIfMissing
were copied from package AutoDoc
where they are named AutoDoc_FindMatchingFiles
and AutoDoc_CreateDirIfMissing.
The string function StringDotSuffixStringDotSuffix
was also copied from package AutoDoc,
where it is named AUTODOC_GetSuffix. GetSuffix
The function SetIfMissingSetIfMissing
was also transferred from package AutoDoc,
where it is called AUTODOC_SetIfMissing.
It writes into a record provided the position is not yet bound.
As from version 0.61, all these functions became obsolete in
Utils,
but continue to be defined in AutoDoc.
Functions for printing
The function PrintOneItemPerLinePrintOneItemPerLine
was used to prints lists vertically, rather than horizontally.
Since a very similar result may be achieved using the &GAP;
library functions Perform and Display,
this function became obsolete in version 0.61.
s3 := SymmetricGroup( 3 );;
gap> L := KnownPropertiesOfObject( GeneratorsOfGroup( s3 ) );;
gap> Perform( L, Display );
IsFinite
IsSmallList
IsGeneratorsOfMagmaWithInverses
IsGeneratorsOfSemigroup
IsSubsetLocallyFiniteGroup
gap> Perform( s3, Display );
()
(2,3)
(1,3)
(1,3,2)
(1,2,3)
(1,2)
]]>
Other obsolete functionsApplicable Methods
The function PrintApplicableMethodPrintApplicableMethod,
which was included in versions from 0.41 to 0.58,
has been removed since it was considered superfluous.
The example shows how to print out a function.
ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 1, 1 );
#I Searching Method for IsCyclic with 1 arguments:
#I Total: 7 entries
#I Method 4: ``IsCyclic'' at /Applications/gap/gap4r9/lib/grp.gi:30 , value:
36
function( G ) ... end
gap> Print( last );
function ( G )
if Length( GeneratorsOfGroup( G ) ) = 1 then
return true;
else
TryNextMethod();
fi;
return;
end
gap> ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 0, 3 );
function( <1 unnamed arguments> ) ... end
gap> Print( last );
function ( <> )
<>
end
]]>
ExponentOfPrime
The function ExponentOfPrimeExponentOfPrime
was originally transferred from package &RCWA;.
The command ExponentOfPrime(n,p) returned the exponent
of the prime p in the prime factorization of n.
Since the &GAP; function PValuation
produces the same results, and does so more quickly,
this function has been made obsolete.
utils-0.93/doc/record.xml 0000644 0001751 0001751 00000011615 15105376105 014767 0 ustar runner runner
RecordsFunctions for records
This function has been transferred from package &RCWA;.
It assigns the record components of rec
to global variables with the same names.
r := rec( a := 1, b := 2, c := 3 );;
gap> AssignGlobals( r );
The following global variables have been assigned:
[ "a", "b", "c" ]
gap> [a,b,c];
[ 1, 2, 3 ]
]]>
Option records for functions
This functions has been transferred by Chris Jefferson from other packages.
It simplifies the handling of records which are intended
to be used for expressing configuration options.
defaults represents the "default record", and useroptions
lets the user give new values for values in defaults.
The function returns a record with the same component names
as defaults and which has the same values as defaults,
except for those component names in useroptions,
where the values in useroptions are used instead.
An error is given if useroptions contains any
component names not in defaults.
If useroptions is an empty list it is treated as an empty record,
and if useroptions is a list of length 1 containing a record,
this record is used as useroptions.
defaults := rec( a := 1, b := 2, c := 3 );;
gap> OptionRecordWithDefaults( defaults, rec( a := 6) );
rec( a := 6, b := 2, c := 3 )
gap> OptionRecordWithDefaults( defaults, rec( b := 7, c := 8 ) );
rec( a := 1, b := 7, c := 8 )
gap> OptionRecordWithDefaults( defaults, [ ] );
rec( a := 1, b := 2, c := 3 )
gap> OptionRecordWithDefaults( defaults, [ rec( c := 8 ) ] );
rec( a := 1, b := 2, c := 8 )
gap> OptionRecordWithDefaults( defaults, rec( d := 9 ) );
Error, Unknown option: d
gap> OptionRecordWithDefaults( defaults, [ rec( b := 7 ), rec( c := 8 ) ] );
Error, Too many arguments for function
gap> OptionRecordWithDefaults( defaults, [6,7,8] );
Error, Too many arguments for function
]]>
This function is designed to support functions with optional arguments
given as a variable record, of the form function(x,y,options...).
In the following, very contrived, example function, PrintDimensions,
the defaults are given by the variable order
which takes values h, w and d
having default values 1, 2 and 3.
If there is a second argument, then
OptionRecordWithDefaults( order, arg[2] ); is used to cvhange the values.
These three values then determine the order in which the three dimensions are printed using a SortParallel command.
1 ) and IsRecord( arg[2] ) then
order := OptionRecordWithDefaults( order, arg[2] );
fi;
L := [ order!.h, order!.w, order!.d ];
len := Length( L );
K := [ 1..len ];
SortParallel( L, K );
Print( "dimensions: " );
Print( V[K[1]], " = ", dim[K[1]], ", " );
Print( V[K[2]], " = ", dim[K[2]], ", " );
Print( V[K[3]], " = ", dim[K[3]], "\n" );
end;;
]]>
In the example below the first call to PrintDimensions
has just one parameter, mydim, so the default order is used.
In the second call, alternate values for h, w and d
are given, causing the width to be printed first,
and then the depth and height.
mydim := rec( height := 45, width := 31, depth := 17 );
rec( depth := 17, height := 45, width := 31 )
gap> PrintDimensions( mydim );
dimensions: height = 45, width = 31, depth = 17
gap> PrintDimensions( mydim, rec( h:=3, w:=1, d:=2 ) );
dimensions: width = 31, depth = 17, height = 45
]]>
utils-0.93/doc/chap7_mj.html 0000644 0001751 0001751 00000027310 15105376105 015344 0 ustar runner runner
GAP (Utils) - Chapter 7: Iterators
7.1 Some iterators for groups and their isomorphisms
The motivation for adding these operations is partly to give a simple example of an iterator for a list that does not yet exist, and need not be created.
7.1-1 AllIsomorphismsIterator
‣ AllIsomorphismsIterator( G, H )
( operation )
‣ AllIsomorphismsNumber( G, H )
( operation )
‣ AllIsomorphisms( G, H )
( operation )
The main GAP library contains functions producing complete lists of group homomorphisms such as AllHomomorphisms; AllEndomorphisms and AllAutomorphisms. Here we add the missing AllIsomorphisms(G,H) for a list of isomorphisms from \(G\) to \(H\). The method is simple -- find one isomorphism \(G \to H\) and compose this with all the automorphisms of \(G\). In all these cases it may not be desirable to construct a list of homomorphisms, but just implement an iterator, and that is what is done here. The operation AllIsomorphismsNumber returns the number of isomorphisms iterated over (this is, of course, just the order of the automorphisms group). The operation AllIsomorphisms produces the list or isomorphisms.
The manual entry for the operation AllSubgroups states that it is only intended to be used on small examples in a classroom situation. Access to all subgroups was required by the XMod package, so this iterator was introduced here. It used the operations LatticeSubgroups(G) and ConjugacyClassesSubgroups(lat), and then iterates over the entries in these classes.
This section considers ways of producing an iterator from one or more iterators. It may be that operations equivalent to these are available elsewhere in the library -- if so, the ones here can be removed in due course.
7.2-1 CartesianIterator
‣ CartesianIterator( iter1, iter2 )
( operation )
This iterator returns all pairs \([x,y]\) where \(x\) is the output of a first iterator and \(y\) is the output of a second iterator.
This operation returns pairs \([x,y]\) where \(x,y\) are output from a given iterator iter. Unlike the output from CartesianIterator(iter,iter), unordered pairs are returned. In the case \(L = [1,2,3,\ldots]\) the pairs are ordered as \([1,1],[1,2],[2,2],[1,3],[2,3],[3,3],\ldots\).
utils-0.93/doc/print.xml 0000644 0001751 0001751 00000004555 15105376105 014652 0 ustar runner runner
Printing Lists and IteratorsPrinting selected items
The functions described here print lists or objects with an iterator
with one item per line, either the whole list/iterator or certain subsets:
by giving a list of positions of items to be printed, or
by specifying a first item and then a regular step.
This function, given three (or four) parameters, calls operations
PrintSelectionFromList or PrintSelectionFromIterator
which prints the first item specified,
and then the item at every step.
The fourth parameter is essential when the object being printed is infinite.
Alternatively, given two parameters,
with the second parameter a list L of positive integers,
only the items at positions in L are printed.
L := List( [1..20], n -> n^5 );;
gap> PrintSelection( L, [18..20] );
18 : 1889568
19 : 2476099
20 : 3200000
gap> PrintSelection( L, 2, 9 );
2 : 32
11 : 161051
20 : 3200000
gap> PrintSelection( L, 2, 3, 11 );
2 : 32
5 : 3125
8 : 32768
11 : 161051
gap> s5 := SymmetricGroup( 5 );;
gap> PrintSelection( s5, [30,31,100,101] );
30 : (1,5)(3,4)
31 : (1,5,2)
100 : (1,4,3)
101 : (1,4)(3,5)
gap> PrintSelection( s5, 1, 30 );
1 : ()
31 : (1,5,2)
61 : (1,2,3)
91 : (1,3,5,2,4)
gap> PrintSelection( s5, 9, 11, 43 );
9 : (2,5,3)
20 : (2,4)
31 : (1,5,2)
42 : (1,5,2,3,4)
]]>
utils-0.93/doc/chap12.html 0000644 0001751 0001751 00000017710 15105376105 014735 0 ustar runner runner
GAP (Utils) - Chapter 12: The transfer procedure
We consider here the process for transferring utility functions from a package Home to Utils which has to avoid the potential problem of duplicate declarations of a function causing loading problems in GAP.
If the functions in Home all have names of the form HOME_FunctionName then, in Utils, these functions are likely to be renamed as FunctionName or something similar. In this case the problem of duplicate declarations does not arise. This is what has happened with transfers from the AutoDoc package.
The case where the function names are unchanged is more complicated. Initially we tried out a process which allowed repeated declarations and installations of the functions being transferred. This involved additions to the main library files global.g and oper.g. Since there were misgivings about interfering in this way with basic operations such as BIND_GLOBAL, a simpler (but slightly less convenient) process has been adopted.
Using this alternative procedure, the following steps will be followed when making transfers from Home to Utils.
(Home:) Offer functions for inclusion. This may be simply done by emailing a list of functions. More usefully, email the declaration, implementation, test and documentation files, e.g.: home.gd, home.gi, home.tst and home.xml. (All active authors should be involved.)
(Home:) Declare that m.n is the last version of Home to contain these functions, so that m.n+1 (or similar) will be the first version of Home to have all these functions removed, and to specify Utils as a required package.
(Utils:) Add strings "home" and "m.n" to the list UtilsPackageVersions in the file utils/lib/start.gd.
While the transfers are being made, it is essential that any new versions of Home should be tested with the latest version of Utils before they are released, so as to avoid loading failures.
(Utils:) Include the function declaration and implementation sections in suitable files, enclosed within a conditional clause of the form:
if OKtoReadFromUtils( "Home" ) then
. . . . . .
<the code>
. . . . . .
fi;
The function OKtoReadFromUtils returns true only if there is an installed version of Home and if this version is greater than m.n. So, at this stage, the copied code will not be read, and the transferred functions can only be called if Home has been installed.
(Utils:) Add the test and documentation material to the appropriate files. The copied code can be tested by temporarily moving Home away from GAP's package directory.
(Utils:) Release a new version of Utils containing all the transferred material.
(Home:) Edit out the declarations and implementations of all the transferred functions, and remove references to them in the manual and tests. Possibly add a note to the manual that these functions have been transferred. Add Utils to the list of Home's required packages in PackageInfo.g. Release a new version of Home.
(Utils:) In due course, when the new version(s) of Home are well established, it may be safe to remove the conditional clauses mentioned in item 4 above. The entry for Home in UtilsPackageLists may then be removed.
Finally, a note on the procedure for testing these functions. As long as a function being transferred still exists in the Home package, the code will not be read from Utils. So, when the tests are run, it is necessary to LoadPackage("home") before the function is called. The file utils/tst/testall.g makes sure that all the necessary packages are loaded before the individual tests are called.
utils-0.93/doc/matrix.xml 0000644 0001751 0001751 00000007731 15105376105 015021 0 ustar runner runner
MatricesSome operations for matrices
In June 2023 Hongyi Zhao asked in the Forum for a function to implement
matrix decomposition into blocks.
Such a function was then provided by Pedro GarcĂa-Sánchez.
Hongyi Zhao then requested that the function be added to
Utils.
What is provided here is a revised version of the original solution,
returning a list of decompositions.
This function is a partial inverse to the undocumented library operation
DirectSumMat.
So if L is the list of diagonal decompositions of a matrix M
then each entry in L is a list of matrices, and the direct sum of
each of these lists is equal to the original M.
In the following examples, M_6 is an obvious direct sum
with 3 blocks.
M_4 is an example with three decompositions,
while M_8 = M_4 \oplus M_4 has 16 decompositions (not listed).
M6 := [ [1,2,0,0,0,0], [3,4,0,0,0,0], [5,6,0,0,0,0],
> [0,0,9,0,0,0], [0,0,0,1,2,3], [0,0,0,4,5,6] ];;
gap> Display( M6 );
[ [ 1, 2, 0, 0, 0, 0 ],
[ 3, 4, 0, 0, 0, 0 ],
[ 5, 6, 0, 0, 0, 0 ],
[ 0, 0, 9, 0, 0, 0 ],
[ 0, 0, 0, 1, 2, 3 ],
[ 0, 0, 0, 4, 5, 6 ] ]
gap> L6 := DirectSumDecompositionMatrices( M6 );
[ [ [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ], [ [ 9 ] ], [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
] ]
gap> M4 := [ [0,3,0,0], [0,0,0,0], [0,0,0,0], [0,0,4,0] ];;
gap> Display( M4 );
[ [ 0, 3, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 0, 0 ],
[ 0, 0, 4, 0 ] ]
gap> L4 := DirectSumDecompositionMatrices( M4 );
[ [ [ [ 0, 3 ] ], [ [ 0, 0 ], [ 0, 0 ], [ 4, 0 ] ] ],
[ [ [ 0, 3 ], [ 0, 0 ] ], [ [ 0, 0 ], [ 4, 0 ] ] ],
[ [ [ 0, 3 ], [ 0, 0 ], [ 0, 0 ] ], [ [ 4, 0 ] ] ] ]
gap> for L in L4 do
> A := DirectSumMat( L );;
> if ( A = M4 ) then Print( "yes, A = M4\n" ); fi;
> od;
yes, A = M4
yes, A = M4
yes, A = M4
gap> M8 := DirectSumMat( M4, M4 );;
gap> Display( M8 );
[ [ 0, 3, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 4, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 3, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 4, 0 ] ]
gap> L8 := DirectSumDecompositionMatrices( M8 );;
gap> Length( L8 );
16
]]>
The current method does not, however, catch all possible decompositions.
In the following example the matrix M_5 has its third row
and third column extirely zero, and the only decomposition found
has a [0] factor.
There are clearly two 2-factor decompositions with a
2-by-3 and a 3-by-2 factor,
but these are not found at present.
M5 := [ [1,2,0,0,0], [3,4,0,0,0], [0,0,0,0,0],
> [0,0,0,6,7], [0,0,0,8,9] ];;
gap> Display(M5);
[ [ 1, 2, 0, 0, 0 ],
[ 3, 4, 0, 0, 0 ],
[ 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 6, 7 ],
[ 0, 0, 0, 8, 9 ] ]
gap> L5 := DirectSumDecompositionMatrices( M5 );
[ [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 0 ] ], [ [ 6, 7 ], [ 8, 9 ] ] ] ]
]]>
utils-0.93/doc/chapInd.html 0000644 0001751 0001751 00000021623 15105376105 015223 0 ustar runner runner
GAP (Utils) - Index
utils-0.93/doc/manual.js 0000644 0001751 0001751 00000010113 15105376105 014572 0 ustar runner runner /* manual.js Frank LĂĽbeck */
/* This file contains a few javascript functions which allow to switch
between display styles for GAPDoc HTML manuals.
If javascript is switched off in a browser or this file in not available
in a manual directory, this is no problem. Users just cannot switch
between several styles and don't see the corresponding button.
A style with name mystyle can be added by providing two files (or only
one of them).
mystyle.js: Additional javascript code for the style, it is
read in the HTML pages after this current file.
The additional code may adjust the preprocessing function
jscontent() with is called onload of a file. This
is done by appending functions to jscontentfuncs
(jscontentfuncs.push(newfunc);).
Make sure, that your style is still usable without
javascript.
mystyle.css: CSS configuration, read after manual.css (so it can
just reconfigure a few details, or overwrite everything).
Then adjust chooser.html such that users can switch on and off mystyle.
A user can change the preferred style permanently by using the [Style]
link and choosing one. Or one can append '?GAPDocStyle=mystyle' to the URL
when loading any file of the manual (so the style can be configured in
the GAP user preferences).
*/
/* generic helper function */
function deleteCookie(nam) {
document.cookie = nam+"=;Path=/;expires=Thu, 01 Jan 1970 00:00:00 GMT";
}
/* read a value from a "nam1=val1;nam2=val2;..." string (e.g., the search
part of an URL or a cookie */
function valueString(str,nam) {
var cs = str.split(";");
for (var i=0; i < cs.length; i++) {
var pos = cs[i].search(nam+"=");
if (pos > -1) {
pos = cs[i].indexOf("=");
return cs[i].slice(pos+1);
}
}
return 0;
}
/* when a non-default style is chosen via URL or a cookie, then
the cookie is reset and the styles .js and .css files are read */
function overwriteStyle() {
/* style in URL? */
var style = valueString(window.location.search, "GAPDocStyle");
/* otherwise check cookie */
if (style == 0)
style = valueString(document.cookie, "GAPDocStyle");
if (style == 0)
return;
if (style == "default")
deleteCookie("GAPDocStyle");
else {
/* ok, we set the cookie for path "/" */
var path = "/";
/* or better like this ???
var here = window.location.pathname.split("/");
for (var i=0; i+3 < here.length; i++)
path = path+"/"+here[i];
*/
document.cookie = "GAPDocStyle="+style+";Path="+path;
/* split into names of style files */
var stlist = style.split(",");
/* read style's css and js files */
for (var i=0; i < stlist.length; i++) {
document.writeln('');
document.writeln('');
}
}
}
/* this adds a "[Style]" link next to the MathJax switcher */
function addStyleLink() {
var line = document.getElementById("mathjaxlink");
var el = document.createElement("a");
var oncl = document.createAttribute("href");
var back = window.location.protocol+"//"
if (window.location.protocol == "http:" ||
window.location.protocol == "https:") {
back = back+window.location.host;
if (window.location.port != "") {
back = back+":"+window.location.port;
}
}
back = back+window.location.pathname;
oncl.nodeValue = "chooser.html?BACK="+back;
el.setAttributeNode(oncl);
var cont = document.createTextNode(" [Style]");
el.appendChild(cont);
line.appendChild(el);
}
var jscontentfuncs = new Array();
jscontentfuncs.push(addStyleLink);
/* the default jscontent() only adds the [Style] link to the page */
function jscontent () {
for (var i=0; i < jscontentfuncs.length; i++)
jscontentfuncs[i]();
}
utils-0.93/doc/chap12.txt 0000644 0001751 0001751 00000013105 15105376105 014602 0 ustar runner runner
[1X12 [33X[0;0YThe transfer procedure[133X[101X
[33X[0;0YWe consider here the process for transferring utility functions from a
package [5XHome[105X to [5XUtils[105X which has to avoid the potential problem of duplicate
declarations of a function causing loading problems in [5XGAP[105X.[133X
[33X[0;0YIf the functions in [5XHome[105X all have names of the form [10XHOME_FunctionName[110X then,
in [5XUtils[105X, these functions are likely to be renamed as [10XFunctionName[110X or
something similar. In this case the problem of duplicate declarations does
not arise. This is what has happened with transfers from the [5XAutoDoc[105X
package.[133X
[33X[0;0YThe case where the function names are unchanged is more complicated.
Initially we tried out a process which allowed repeated declarations and
installations of the functions being transferred. This involved additions to
the main library files [11Xglobal.g[111X and [11Xoper.g[111X. Since there were misgivings
about interfering in this way with basic operations such as [10XBIND_GLOBAL[110X, a
simpler (but slightly less convenient) process has been adopted.[133X
[33X[0;0YUsing this alternative procedure, the following steps will be followed when
making transfers from [5XHome[105X to [5XUtils[105X.[133X
[31X1[131X [33X[0;6Y([5XHome[105X:) Offer functions for inclusion. This may be simply done by
emailing a list of functions. More usefully, email the declaration,
implementation, test and documentation files, e.g.: [11Xhome.gd[111X, [11Xhome.gi[111X,
[11Xhome.tst[111X and [11Xhome.xml[111X. (All active authors should be involved.)[133X
[31X2[131X [33X[0;6Y([5XHome[105X:) Declare that [12Xm.n[112X is the last version of [5XHome[105X to contain these
functions, so that [12Xm.n+1[112X (or similar) will be the first version of
[5XHome[105X to have all these functions removed, and to specify [5XUtils[105X as a
required package.[133X
[31X3[131X [33X[0;6Y([5XUtils[105X:) Add strings [3X"home"[103X and [3X"m.n"[103X to the list [10XUtilsPackageVersions[110X
in the file [11Xutils/lib/start.gd[111X.[133X
[4X [32X Example [32X[104X
[4X[28X[128X[104X
[4X[28XUtilsPackageVersions := [128X[104X
[4X[28X [ "autodoc", "2016.01.31", [128X[104X
[4X[28X "resclasses", "4.2.5", [128X[104X
[4X[28X "home", "m.n",[128X[104X
[4X[28X ..., ... [128X[104X
[4X[28X ];[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[33X[0;6YWhile the transfers are being made, it is essential that any new
versions of [5XHome[105X should be tested with the latest version of [5XUtils[105X
before they are released, so as to avoid loading failures.[133X
[31X4[131X [33X[0;6Y([5XUtils[105X:) Include the function declaration and implementation sections
in suitable files, enclosed within a conditional clause of the form:[133X
[4X [32X Example [32X[104X
[4X[28X[128X[104X
[4X[28Xif OKtoReadFromUtils( "Home" ) then[128X[104X
[4X[28X. . . . . . [128X[104X
[4X[28X [128X[104X
[4X[28X. . . . . . [128X[104X
[4X[28Xfi;[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[33X[0;6YThe function [10XOKtoReadFromUtils[110X returns [9Xtrue[109X only if there is an
installed version of [5XHome[105X and if this version is greater than [12Xm.n[112X. So,
at this stage, [13Xthe copied code will not be read[113X, and the transferred
functions can only be called if [5XHome[105X has been installed.[133X
[31X5[131X [33X[0;6Y([5XUtils[105X:) Add the test and documentation material to the appropriate
files. The copied code can be tested by temporarily moving [5XHome[105X away
from [5XGAP[105X's package directory.[133X
[31X6[131X [33X[0;6Y([5XUtils[105X:) Release a new version of [5XUtils[105X containing all the transferred
material.[133X
[31X7[131X [33X[0;6Y([5XHome[105X:) Edit out the declarations and implementations of all the
transferred functions, and remove references to them in the manual and
tests. Possibly add a note to the manual that these functions have
been transferred. Add [5XUtils[105X to the list of [5XHome[105X's required packages in
[11XPackageInfo.g[111X. Release a new version of [5XHome[105X.[133X
[31X8[131X [33X[0;6Y([5XUtils[105X:) In due course, when the new version(s) of [5XHome[105X are well
established, it may be safe to remove the conditional clauses
mentioned in item 4 above. The entry for [5XHome[105X in [10XUtilsPackageLists[110X may
then be removed.[133X
[33X[0;0YFinally, a note on the procedure for testing these functions. As long as a
function being transferred still exists in the [5XHome[105X package, the code will
not be read from [5XUtils[105X. So, when the tests are run, it is necessary to
[10XLoadPackage("home")[110X before the function is called. The file
[11Xutils/tst/testall.g[111X makes sure that all the necessary packages are loaded
before the individual tests are called.[133X
utils-0.93/doc/iterator.xml 0000644 0001751 0001751 00000012325 15105376105 015341 0 ustar runner runner
IteratorsSome iterators for groups and their isomorphismsIterators
The motivation for adding these operations is partly to give a simple example
of an iterator for a list that does not yet exist, and need not be created.
The main &GAP; library contains functions producing complete lists of
group homomorphisms such as AllHomomorphisms; AllEndomorphisms
and AllAutomorphisms.
Here we add the missing AllIsomorphisms(G,H) for a list of isomorphisms
from G to H.
The method is simple -- find one isomorphism G \to H and compose this
with all the automorphisms of G.
In all these cases it may not be desirable to construct a list of
homomorphisms, but just implement an iterator, and that is what is done here.
The operation AllIsomorphismsNumber returns the number of isomorphisms
iterated over (this is, of course, just the order of the automorphisms group).
The operation AllIsomorphisms produces the list or isomorphisms.
G := SmallGroup( 6,1);;
gap> iter := AllIsomorphismsIterator( G, s3 );;
gap> NextIterator( iter );
[ f1, f2 ] -> [ (6,7), (5,6,7) ]
gap> n := AllIsomorphismsNumber( G, s3 );
6
gap> AllIsomorphisms( G, s3 );
[ [ f1, f2 ] -> [ (6,7), (5,6,7) ], [ f1, f2 ] -> [ (5,7), (5,6,7) ],
[ f1, f2 ] -> [ (5,6), (5,7,6) ], [ f1, f2 ] -> [ (6,7), (5,7,6) ],
[ f1, f2 ] -> [ (5,7), (5,7,6) ], [ f1, f2 ] -> [ (5,6), (5,6,7) ] ]
gap> iter := AllIsomorphismsIterator( G, s3 );;
gap> for h in iter do Print( ImageElm( h, G.1 ) = (6,7), ", " ); od;
true, false, false, true, false, false,
]]>
The manual entry for the operation AllSubgroups states that it is only
intended to be used on small examples in a classroom situation.
Access to all subgroups was required by the XMod package,
so this iterator was introduced here.
It used the operations LatticeSubgroups(G)
and ConjugacyClassesSubgroups(lat), and then iterates
over the entries in these classes.
c3c3 := Group( (1,2,3), (4,5,6) );;
gap> iter := AllSubgroupsIterator( c3c3 );
gap> while not IsDoneIterator(iter) do Print(NextIterator(iter),"\n"); od;
Group( () )
Group( [ (4,5,6) ] )
Group( [ (1,2,3) ] )
Group( [ (1,2,3)(4,5,6) ] )
Group( [ (1,3,2)(4,5,6) ] )
Group( [ (4,5,6), (1,2,3) ] )
]]>
Operations on iterators
This section considers ways of producing an iterator
from one or more iterators.
It may be that operations equivalent to these are available elsewhere
in the library -- if so, the ones here can be removed in due course.
This iterator returns all pairs [x,y] where x is the output
of a first iterator and y is the output of a second iterator.
it1 := Iterator( [ 1, 2, 3 ] );;
gap> it2 := Iterator( [ 4, 5, 6 ] );;
gap> iter := CartesianIterator( it1, it2 );;
gap> while not IsDoneIterator(iter) do Print(NextIterator(iter),"\n"); od;
[ 1, 4 ]
[ 1, 5 ]
[ 1, 6 ]
[ 2, 4 ]
[ 2, 5 ]
[ 2, 6 ]
[ 3, 4 ]
[ 3, 5 ]
[ 3, 6 ]
]]>
This operation returns pairs [x,y] where x,y are output
from a given iterator iter.
Unlike the output from CartesianIterator(iter,iter),
unordered pairs are returned.
In the case L = [1,2,3,\ldots] the pairs are ordered as
[1,1],[1,2],[2,2],[1,3],[2,3],[3,3],\ldots.
L := [6,7,8,9];;
gap> iterL := IteratorList( L );;
gap> pairsL := UnorderedPairsIterator( iterL );;
gap> while not IsDoneIterator(pairsL) do Print(NextIterator(pairsL),"\n"); od;
[ 6, 6 ]
[ 6, 7 ]
[ 7, 7 ]
[ 6, 8 ]
[ 7, 8 ]
[ 8, 8 ]
[ 6, 9 ]
[ 7, 9 ]
[ 8, 9 ]
[ 9, 9 ]
gap> iter4 := IteratorList( [ 4 ] );
gap> pairs4 := UnorderedPairsIterator(iter4);
gap> NextIterator( pairs4 );
[ 4, 4 ]
gap> IsDoneIterator( pairs4 );
true
]]>
utils-0.93/doc/manual.css 0000644 0001751 0001751 00000015754 15105376105 014766 0 ustar runner runner /* manual.css Frank LĂĽbeck */
/* This is the default CSS style sheet for GAPDoc HTML manuals. */
/* basic settings, fonts, sizes, colors, ... */
body {
position: relative;
background: #ffffff;
color: #000000;
width: 70%;
margin: 0pt;
padding: 15pt;
font-family: Helvetica,Verdana,Arial,sans-serif;
text-align: justify;
}
/* no side toc on title page, bib and index */
body.chap0 {
width: 95%;
}
body.chapBib {
width: 95%;
}
body.chapInd {
width: 95%;
}
h1 { font-size: 200%; }
h2 { font-size: 160%; }
h3 { font-size: 160%; }
h4 { font-size: 130%; }
h5 { font-size: 100%; }
p.foot {
font-size: 60%;
font-style: normal;
}
a:link {
color: #00008e;
text-decoration: none;
}
a:visited {
color: #00008e;
text-decoration: none;
}
a:active {
color: #000000;
text-decoration: none;
}
a:hover {
background: #eeeeee;
}
pre {
font-family: "Courier New",Courier,monospace;
font-size: 100%;
color:#111111;
}
tt,code {
font-family: "Courier New",Courier,monospace;
font-size: 110%;
color: #000000; }
var {
}
/* general alignment classes */
.pcenter {
text-align: center;
}
.pleft {
text-align: left;
}
.pright {
text-align: right;
}
/* layout for the definitions of functions, variables, ... */
div.func {
background: #e0e0e0;
margin: 0pt 0pt;
}
/* general and special table settings */
table {
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
}
td, th {
border-style: none;
}
table.func {
padding: 0pt 1ex;
margin-left: 1ex;
margin-right: 1ex;
background: transparent;
/* line-height: 1.1; */
width: 100%;
}
table.func td.tdright {
padding-right: 2ex;
}
/* Example elements (for old converted manuals, now in div+pre */
table.example {
background: #efefef;
border-style: none;
border-width: 0pt;
padding: 0px;
width: 100%
}
table.example td {
border-style: none;
border-width: 0pt;
padding: 0ex 1ex;
}
/* becomes ... */
div.example {
background: #efefef;
padding: 0ex 1ex;
/* overflow-x: auto; */
overflow: auto;
}
/* Links to chapters in all files at top and bottom. */
/* If there are too many chapters then use 'display: none' here. */
div.chlinktop {
background: #dddddd;
border-style: solid;
border-width: thin;
margin: 2px;
text-align: center;
}
div.chlinktop a {
margin: 3px;
}
div.chlinktop a:hover {
background: #ffffff;
}
div.chlinkbot {
background: #dddddd;
border-style: solid;
border-width: thin;
margin: 2px;
text-align: center;
/* width: 100%; */
}
div.chlinkbot a {
margin: 3px;
}
span.chlink1 {
}
/* and this is for the "Top", "Prev", "Next" links */
div.chlinkprevnexttop {
background: #dddddd;
border-style: solid;
border-width: thin;
text-align: center;
margin: 2px;
}
div.chlinkprevnexttop a:hover {
background: #ffffff;
}
div.chlinkprevnextbot {
background: #dddddd;
border-style: solid;
border-width: thin;
text-align: center;
margin: 2px;
}
div.chlinkprevnextbot a:hover {
background: #ffffff;
}
/* table of contents, initially don't display subsections */
div.ContSSBlock {
display: none;
}
div.ContSSBlock br {
display: none;
}
/* format in separate lines */
span.tocline {
display: block;
width: 100%;
}
div.ContSSBlock a {
display: block;
}
/* this is for the main table of contents */
div.ContChap {
}
div.ContChap div.ContSect:hover div.ContSSBlock {
display: block;
position: absolute;
background: #eeeeee;
border-style: solid;
border-width: 1px 4px 4px 1px;
border-color: #666666;
padding-left: 0.5ex;
color: #000000;
left: 20%;
width: 40%;
z-index: 10000;
}
div.ContSSBlock a:hover {
background: #ffffff;
}
/* and here for the side menu of contents in the chapter files */
div.ChapSects {
}
div.ChapSects a:hover {
background: #eeeeee;
}
div.ChapSects a:hover {
display: block;
width: 100%;
background: #eeeeee;
color: #000000;
}
div.ChapSects div.ContSect:hover div.ContSSBlock {
display: block;
position: fixed;
background: #eeeeee;
border-style: solid;
border-width: 1px 2px 2px 1px;
border-color: #666666;
padding-left: 0ex;
padding-right: 0.5ex;
color: #000000;
left: 54%;
width: 25%;
z-index: 10000;
}
div.ChapSects div.ContSect:hover div.ContSSBlock a {
display: block;
margin-left: 3px;
}
div.ChapSects div.ContSect:hover div.ContSSBlock a:hover {
display: block;
background: #ffffff;
}
div.ContSect {
text-align: left;
margin-left: 1em;
}
div.ChapSects {
position: fixed;
left: 75%;
font-size: 90%;
overflow: auto;
top: 10px;
bottom: 0px;
}
/* Table elements */
table.GAPDocTable {
border-collapse: collapse;
border-style: none;
border-color: black;
}
table.GAPDocTable td, table.GAPDocTable th {
padding: 3pt;
border-width: thin;
border-style: solid;
border-color: #555555;
}
caption.GAPDocTable {
caption-side: bottom;
width: 70%;
margin-top: 1em;
margin-left: auto;
margin-right: auto;
}
td.tdleft {
text-align: left;
}
table.GAPDocTablenoborder {
border-collapse: collapse;
border-style: none;
border-color: black;
}
table.GAPDocTablenoborder td, table.GAPDocTable th {
padding: 3pt;
border-width: 0pt;
border-style: solid;
border-color: #555555;
}
caption.GAPDocTablenoborder {
caption-side: bottom;
width: 70%;
margin-top: 1em;
margin-left: auto;
margin-right: auto;
}
td.tdleft {
text-align: left;
}
td.tdright {
text-align: right;
}
td.tdcenter {
text-align: center;
}
/* Colors and fonts can be overwritten for some types of elements. */
/* Verb elements */
pre.normal {
color: #000000;
}
/* Func-like elements and Ref to Func-like */
code.func {
color: #000000;
}
/* K elements */
code.keyw {
color: #770000;
}
/* F elements */
code.file {
color: #8e4510;
}
/* C elements */
code.code {
}
/* Item elements */
code.i {
}
/* Button elements */
strong.button {
}
/* Headings */
span.Heading {
}
/* Arg elements */
var.Arg {
color: #006600;
}
/* Example elements, is in tables, see above */
div.Example {
}
/* Package elements */
strong.pkg {
}
/* URL-like elements */
span.URL {
}
/* Mark elements */
strong.Mark {
}
/* Ref elements */
b.Ref {
}
span.Ref {
}
/* this contains the contents page */
div.contents {
}
/* this contains the index page */
div.index {
}
/* ignore some text for non-css layout */
span.nocss {
display: none;
}
/* colors for ColorPrompt like examples */
span.GAPprompt {
color: #000097;
font-weight: normal;
}
span.GAPbrkprompt {
color: #970000;
font-weight: normal;
}
span.GAPinput {
color: #970000;
}
/* Bib entries */
p.BibEntry {
}
span.BibKey {
color: #005522;
}
span.BibKeyLink {
}
b.BibAuthor {
}
i.BibTitle {
}
i.BibBookTitle {
}
span.BibEditor {
}
span.BibJournal {
}
span.BibType {
}
span.BibPublisher {
}
span.BibSchool {
}
span.BibEdition {
}
span.BibVolume {
}
span.BibSeries {
}
span.BibNumber {
}
span.BibPages {
}
span.BibOrganization {
}
span.BibAddress {
}
span.BibYear {
}
span.BibPublisher {
}
span.BibNote {
}
span.BibHowpublished {
}
utils-0.93/doc/chap8_mj.html 0000644 0001751 0001751 00000023424 15105376105 015347 0 ustar runner runner
GAP (Utils) - Chapter 8: Records
This function has been transferred from package RCWA.
It assigns the record components of rec to global variables with the same names.
gap>r := rec( a := 1, b := 2, c := 3 );; gap>AssignGlobals( r );
The following global variables have been assigned:
[ "a", "b", "c" ]
gap>[a,b,c];
[ 1, 2, 3 ]
This functions has been transferred by Chris Jefferson from other packages. It simplifies the handling of records which are intended to be used for expressing configuration options. defaults represents the "default record", and useroptions lets the user give new values for values in defaults.
The function returns a record with the same component names as defaults and which has the same values as defaults, except for those component names in useroptions, where the values in useroptions are used instead. An error is given if useroptions contains any component names not in defaults. If useroptions is an empty list it is treated as an empty record, and if useroptions is a list of length \(1\) containing a record, this record is used as useroptions.
gap>defaults := rec( a := 1, b := 2, c := 3 );;gap>OptionRecordWithDefaults( defaults, rec( a := 6) );
rec( a := 6, b := 2, c := 3 )
gap>OptionRecordWithDefaults( defaults, rec( b := 7, c := 8 ) );
rec( a := 1, b := 7, c := 8 )
gap>OptionRecordWithDefaults( defaults, [ ] );
rec( a := 1, b := 2, c := 3 )
gap>OptionRecordWithDefaults( defaults, [ rec( c := 8 ) ] );
rec( a := 1, b := 2, c := 8 )
gap>OptionRecordWithDefaults( defaults, rec( d := 9 ) );
Error, Unknown option: d
gap>OptionRecordWithDefaults( defaults, [ rec( b := 7 ), rec( c := 8 ) ] );
Error, Too many arguments for function
gap>OptionRecordWithDefaults( defaults, [6,7,8] );
Error, Too many arguments for function
This function is designed to support functions with optional arguments given as a variable record, of the form function(x,y,options...). In the following, very contrived, example function, PrintDimensions, the defaults are given by the variable order which takes values h, w and d having default values \(1\), \(2\) and \(3\). If there is a second argument, then OptionRecordWithDefaults( order, arg[2] ); is used to cvhange the values. These three values then determine the order in which the three dimensions are printed using a SortParallel command.
PrintDimensions := function( arg )
local nargs, dim, order, V, L, len, K, i;
nargs := Length( arg );
dim := [ arg[1]!.height, arg[1]!.width, arg[1]!.depth ];
order := rec( h := 1, w := 2, d := 3 );
V := [ "height", "width", "depth" ];
if ( nargs > 1 ) and IsRecord( arg[2] ) then
order := OptionRecordWithDefaults( order, arg[2] );
fi;
L := [ order!.h, order!.w, order!.d ];
len := Length( L );
K := [ 1..len ];
SortParallel( L, K );
Print( "dimensions: " );
Print( V[K[1]], " = ", dim[K[1]], ", " );
Print( V[K[2]], " = ", dim[K[2]], ", " );
Print( V[K[3]], " = ", dim[K[3]], "\n" );
end;;
In the example below the first call to PrintDimensions has just one parameter, mydim, so the default order is used. In the second call, alternate values for h, w and d are given, causing the width to be printed first, and then the depth and height.
The file functions FindMatchingFiles and CreateDirIfMissing were copied from package AutoDoc where they are named AutoDoc_FindMatchingFiles and AutoDoc_CreateDirIfMissing.
The string function StringDotSuffix was also copied from package AutoDoc, where it is named AUTODOC_GetSuffix.
The function SetIfMissing was also transferred from package AutoDoc, where it is called AUTODOC_SetIfMissing. It writes into a record provided the position is not yet bound.
As from version 0.61, all these functions became obsolete in Utils, but continue to be defined in AutoDoc.
11.2 Functions for printing
The function PrintOneItemPerLine was used to prints lists vertically, rather than horizontally. Since a very similar result may be achieved using the GAP library functions Perform and Display, this function became obsolete in version 0.61.
The function PrintApplicableMethod, which was included in versions from 0.41 to 0.58, has been removed since it was considered superfluous. The example shows how to print out a function.
gap>ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 1, 1 );
#I Searching Method for IsCyclic with 1 arguments:
#I Total: 7 entries
#I Method 4: ``IsCyclic'' at /Applications/gap/gap4r9/lib/grp.gi:30 , value:
36
function( G ) ... end
gap>Print( last );
function ( G )
if Length( GeneratorsOfGroup( G ) ) = 1 then
return true;
else
TryNextMethod();
fi;
return;
end
gap>ApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 0, 3 );
function( <1 unnamed arguments> ) ... end
gap>Print( last );
function ( <<arg-1>> )
<<compiled GAP code from GAPROOT/lib/oper1.g:578>>
end
11.3-2 ExponentOfPrime
The function ExponentOfPrime was originally transferred from package RCWA. The command ExponentOfPrime(n,p) returned the exponent of the prime p in the prime factorization of n.
Since the GAP function PValuation produces the same results, and does so more quickly, this function has been made obsolete.
utils-0.93/doc/chap2.txt 0000644 0001751 0001751 00000005356 15105376105 014532 0 ustar runner runner
[1X2 [33X[0;0YPrinting Lists and Iterators[133X[101X
[1X2.1 [33X[0;0YPrinting selected items[133X[101X
[33X[0;0YThe functions described here print lists or objects with an iterator with
one item per line, either the whole list/iterator or certain subsets:[133X
[30X [33X[0;6Yby giving a list of positions of items to be printed, or[133X
[30X [33X[0;6Yby specifying a first item and then a regular step.[133X
[1X2.1-1 PrintSelection[101X
[33X[1;0Y[29X[2XPrintSelection[102X( [3Xobj[103X, [3Xlist[103X ) [32X function[133X
[33X[1;0Y[29X[2XPrintSelection[102X( [3Xobj[103X, [3Xfirst[103X, [3Xstep[103X[, [3Xlast[103X] ) [32X function[133X
[33X[0;0YThis function, given three (or four) parameters, calls operations
[10XPrintSelectionFromList[110X or [10XPrintSelectionFromIterator[110X which prints the [13Xfirst[113X
item specified, and then the item at every [13Xstep[113X. The fourth parameter is
essential when the object being printed is infinite.[133X
[33X[0;0YAlternatively, given two parameters, with the second parameter a list [10XL[110X of
positive integers, only the items at positions in [10XL[110X are printed.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XL := List( [1..20], n -> n^5 );;[127X[104X
[4X[25Xgap>[125X [27XPrintSelection( L, [18..20] );[127X[104X
[4X[28X18 : 1889568[128X[104X
[4X[28X19 : 2476099[128X[104X
[4X[28X20 : 3200000[128X[104X
[4X[25Xgap>[125X [27XPrintSelection( L, 2, 9 ); [127X[104X
[4X[28X2 : 32[128X[104X
[4X[28X11 : 161051[128X[104X
[4X[28X20 : 3200000[128X[104X
[4X[25Xgap>[125X [27XPrintSelection( L, 2, 3, 11 );[127X[104X
[4X[28X2 : 32[128X[104X
[4X[28X5 : 3125[128X[104X
[4X[28X8 : 32768[128X[104X
[4X[28X11 : 161051[128X[104X
[4X[25Xgap>[125X [27Xs5 := SymmetricGroup( 5 );;[127X[104X
[4X[25Xgap>[125X [27XPrintSelection( s5, [30,31,100,101] );[127X[104X
[4X[28X30 : (1,5)(3,4)[128X[104X
[4X[28X31 : (1,5,2)[128X[104X
[4X[28X100 : (1,4,3)[128X[104X
[4X[28X101 : (1,4)(3,5)[128X[104X
[4X[25Xgap>[125X [27XPrintSelection( s5, 1, 30 );[127X[104X
[4X[28X1 : ()[128X[104X
[4X[28X31 : (1,5,2)[128X[104X
[4X[28X61 : (1,2,3)[128X[104X
[4X[28X91 : (1,3,5,2,4)[128X[104X
[4X[25Xgap>[125X [27XPrintSelection( s5, 9, 11, 43 );[127X[104X
[4X[28X9 : (2,5,3)[128X[104X
[4X[28X20 : (2,4)[128X[104X
[4X[28X31 : (1,5,2)[128X[104X
[4X[28X42 : (1,5,2,3,4)[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
utils-0.93/doc/chap1.html 0000644 0001751 0001751 00000020726 15105376105 014654 0 ustar runner runner
GAP (Utils) - Chapter 1: Introduction
The Utils package provides a space for utility functions from a variety of GAP packages to be collected together into a single package. In this way it is hoped that they will become more visible to other package authors. This package was first distributed as part of the GAP 4.8.2 distribution.
The package is loaded with the command
gap>LoadPackage( "utils" );
Functions have been transferred from the following packages:
Conversion of a GAP group to a Magma output string, taken from various sources including other.gi in the main library.
Transfer is complete (for now) for functions from the following packages:
Once the package is loaded, the manual doc/manual.pdf can be found in the documentation folder. The html versions, with or without MathJax, may be rebuilt as follows:
gap>ReadPackage( "utils", "makedoc.g" );
It is possible to check that the package has been installed correctly by running the test files (which terminates the GAP session):
Note that functions listed in this manual that are currently in the process of being transferred are only read from the source package Home (say), and so can only be used if Home has already been loaded. There are no such functions in transition at present.
1.1 Information for package authors
A function (or collection of functions) is suitable for transfer from a package Home to Utils if the following conditions are satisfied.
The function is sufficiently non-specialised so that it might be of use to other authors.
The function does not depend on the remaining functions in Home
The function does not do what can already be done with a GAP library function.
Documentation of the function and test examples are available.
When there is more than one active author of Home, they should all be aware (and content) that the transfer is taking place.
Authors of packages may be reluctant to let go of their utility functions. The following principles may help to reassure them. (Suggestions for more items here are welcome.)
A function that has been transferred to Utils will not be changed without the approval of the original author.
The current package maintainer has every intention of continuing to maintain Utils. In the event that this proves impossible, the GAP development team will surely find someone to take over.
Function names will not be changed unless specifically requested by Home's author(s) or unless they have the form HOME_FunctionName.
In order to speed up the transfer process, only functions from one package will be in transition at any given time. Hopefully a week or two will suffice for most packages.
Any package author who transfers a function to Utils will become an author of Utils. (In truth, Utils does not have authors, just a large number of contributors.)
The process for transferring utility functions from Home to Utils is described in Chapter 12.
utils-0.93/doc/transfer.xml 0000644 0001751 0001751 00000011463 15105376105 015336 0 ustar runner runner
The transfer procedure
We consider here the process for transferring utility functions
from a package &Home; to &Utils; which has to avoid the potential problem
of duplicate declarations of a function causing loading problems in &GAP;.
If the functions in &Home; all have names of the form
HOME_FunctionName then, in &Utils;, these functions
are likely to be renamed as FunctionName or something similar.
In this case the problem of duplicate declarations does not arise.
This is what has happened with transfers from the &AutoDoc; package.
The case where the function names are unchanged is more complicated.
Initially we tried out a process which allowed repeated declarations and
installations of the functions being transferred.
This involved additions to the main library files global.g
and oper.g.
Since there were misgivings about interfering in this way
with basic operations such as BIND_GLOBAL,
a simpler (but slightly less convenient) process has been adopted.
Using this alternative procedure, the following steps will be followed
when making transfers from &Home; to &Utils;.
(&Home;:)
Offer functions for inclusion.
This may be simply done by emailing a list of functions.
More usefully, email the declaration, implementation, test and
documentation files, e.g.: home.gd,
home.gi, home.tst and home.xml.
(All active authors should be involved.)
(&Home;:)
Declare that m.n is the last version of &Home;
to contain these functions, so that m.n+1 (or similar)
will be the first version of &Home; to have all these functions
removed, and to specify &Utils; as a required package.
(&Utils;:)
Add strings "home" and "m.n" to the list
UtilsPackageVersions in the file utils/lib/start.gd.
While the transfers are being made, it is essential that any new versions
of &Home; should be tested with the latest version of &Utils;
before they are released, so as to avoid loading failures.
(&Utils;:)
Include the function declaration and implementation sections
in suitable files, enclosed within a conditional clause of the form:
. . . . . .
fi;
]]>
OKtoReadFromUtils
The function OKtoReadFromUtils returns true
only if there is an installed version of &Home;
and if this version is greater than m.n.
So, at this stage, the copied code will not be read,
and the transferred functions can only be called if &Home;
has been installed.
(&Utils;:)
Add the test and documentation material to the appropriate files.
The copied code can be tested by temporarily moving &Home; away from
&GAP;'s package directory.
(&Utils;:)
Release a new version of &Utils; containing all the transferred material.
(&Home;:)
Edit out the declarations and implementations of all the transferred functions,
and remove references to them in the manual and tests.
Possibly add a note to the manual that these functions have been transferred.
Add &Utils; to the list of &Home;'s required packages
in PackageInfo.g.
Release a new version of &Home;.
(&Utils;:)
In due course, when the new version(s) of &Home; are well established,
it may be safe to remove the conditional clauses mentioned in item 4 above.
The entry for &Home; in UtilsPackageLists may then be removed.
Finally, a note on the procedure for testing these functions.
As long as a function being transferred still exists in the &Home; package,
the code will not be read from &Utils;.
So, when the tests are run, it is necessary to LoadPackage("home")
before the function is called.
The file utils/tst/testall.g makes sure that all the necessary
packages are loaded before the individual tests are called.
utils-0.93/doc/chap8.html 0000644 0001751 0001751 00000023004 15105376105 014653 0 ustar runner runner
GAP (Utils) - Chapter 8: Records
This function has been transferred from package RCWA.
It assigns the record components of rec to global variables with the same names.
gap>r := rec( a := 1, b := 2, c := 3 );; gap>AssignGlobals( r );
The following global variables have been assigned:
[ "a", "b", "c" ]
gap>[a,b,c];
[ 1, 2, 3 ]
This functions has been transferred by Chris Jefferson from other packages. It simplifies the handling of records which are intended to be used for expressing configuration options. defaults represents the "default record", and useroptions lets the user give new values for values in defaults.
The function returns a record with the same component names as defaults and which has the same values as defaults, except for those component names in useroptions, where the values in useroptions are used instead. An error is given if useroptions contains any component names not in defaults. If useroptions is an empty list it is treated as an empty record, and if useroptions is a list of length 1 containing a record, this record is used as useroptions.
gap>defaults := rec( a := 1, b := 2, c := 3 );;gap>OptionRecordWithDefaults( defaults, rec( a := 6) );
rec( a := 6, b := 2, c := 3 )
gap>OptionRecordWithDefaults( defaults, rec( b := 7, c := 8 ) );
rec( a := 1, b := 7, c := 8 )
gap>OptionRecordWithDefaults( defaults, [ ] );
rec( a := 1, b := 2, c := 3 )
gap>OptionRecordWithDefaults( defaults, [ rec( c := 8 ) ] );
rec( a := 1, b := 2, c := 8 )
gap>OptionRecordWithDefaults( defaults, rec( d := 9 ) );
Error, Unknown option: d
gap>OptionRecordWithDefaults( defaults, [ rec( b := 7 ), rec( c := 8 ) ] );
Error, Too many arguments for function
gap>OptionRecordWithDefaults( defaults, [6,7,8] );
Error, Too many arguments for function
This function is designed to support functions with optional arguments given as a variable record, of the form function(x,y,options...). In the following, very contrived, example function, PrintDimensions, the defaults are given by the variable order which takes values h, w and d having default values 1, 2 and 3. If there is a second argument, then OptionRecordWithDefaults( order, arg[2] ); is used to cvhange the values. These three values then determine the order in which the three dimensions are printed using a SortParallel command.
PrintDimensions := function( arg )
local nargs, dim, order, V, L, len, K, i;
nargs := Length( arg );
dim := [ arg[1]!.height, arg[1]!.width, arg[1]!.depth ];
order := rec( h := 1, w := 2, d := 3 );
V := [ "height", "width", "depth" ];
if ( nargs > 1 ) and IsRecord( arg[2] ) then
order := OptionRecordWithDefaults( order, arg[2] );
fi;
L := [ order!.h, order!.w, order!.d ];
len := Length( L );
K := [ 1..len ];
SortParallel( L, K );
Print( "dimensions: " );
Print( V[K[1]], " = ", dim[K[1]], ", " );
Print( V[K[2]], " = ", dim[K[2]], ", " );
Print( V[K[3]], " = ", dim[K[3]], "\n" );
end;;
In the example below the first call to PrintDimensions has just one parameter, mydim, so the default order is used. In the second call, alternate values for h, w and d are given, causing the width to be printed first, and then the depth and height.
utils-0.93/doc/chap7.txt 0000644 0001751 0001751 00000015723 15105376105 014536 0 ustar runner runner
[1X7 [33X[0;0YIterators[133X[101X
[1X7.1 [33X[0;0YSome iterators for groups and their isomorphisms[133X[101X
[33X[0;0YThe motivation for adding these operations is partly to give a simple
example of an iterator for a list that does not yet exist, and need not be
created.[133X
[1X7.1-1 AllIsomorphismsIterator[101X
[33X[1;0Y[29X[2XAllIsomorphismsIterator[102X( [3XG[103X, [3XH[103X ) [32X operation[133X
[33X[1;0Y[29X[2XAllIsomorphismsNumber[102X( [3XG[103X, [3XH[103X ) [32X operation[133X
[33X[1;0Y[29X[2XAllIsomorphisms[102X( [3XG[103X, [3XH[103X ) [32X operation[133X
[33X[0;0YThe main [5XGAP[105X library contains functions producing complete lists of group
homomorphisms such as [10XAllHomomorphisms[110X; [10XAllEndomorphisms[110X and
[10XAllAutomorphisms[110X. Here we add the missing [10XAllIsomorphisms(G,H)[110X for a list of
isomorphisms from [22XG[122X to [22XH[122X. The method is simple -- find one isomorphism [22XG ->
H[122X and compose this with all the automorphisms of [22XG[122X. In all these cases it
may not be desirable to construct a list of homomorphisms, but just
implement an iterator, and that is what is done here. The operation
[10XAllIsomorphismsNumber[110X returns the number of isomorphisms iterated over (this
is, of course, just the order of the automorphisms group). The operation
[10XAllIsomorphisms[110X produces the list or isomorphisms.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XG := SmallGroup( 6,1);; [127X[104X
[4X[25Xgap>[125X [27Xiter := AllIsomorphismsIterator( G, s3 );;[127X[104X
[4X[25Xgap>[125X [27XNextIterator( iter );[127X[104X
[4X[28X[ f1, f2 ] -> [ (6,7), (5,6,7) ][128X[104X
[4X[25Xgap>[125X [27Xn := AllIsomorphismsNumber( G, s3 );[127X[104X
[4X[28X6[128X[104X
[4X[25Xgap>[125X [27XAllIsomorphisms( G, s3 );[127X[104X
[4X[28X[ [ f1, f2 ] -> [ (6,7), (5,6,7) ], [ f1, f2 ] -> [ (5,7), (5,6,7) ], [128X[104X
[4X[28X [ f1, f2 ] -> [ (5,6), (5,7,6) ], [ f1, f2 ] -> [ (6,7), (5,7,6) ], [128X[104X
[4X[28X [ f1, f2 ] -> [ (5,7), (5,7,6) ], [ f1, f2 ] -> [ (5,6), (5,6,7) ] ][128X[104X
[4X[25Xgap>[125X [27Xiter := AllIsomorphismsIterator( G, s3 );;[127X[104X
[4X[25Xgap>[125X [27Xfor h in iter do Print( ImageElm( h, G.1 ) = (6,7), ", " ); od;[127X[104X
[4X[28Xtrue, false, false, true, false, false,[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X7.1-2 AllSubgroupsIterator[101X
[33X[1;0Y[29X[2XAllSubgroupsIterator[102X( [3XG[103X ) [32X operation[133X
[33X[0;0YThe manual entry for the operation [10XAllSubgroups[110X states that it is only
intended to be used on small examples in a classroom situation. Access to
all subgroups was required by the [5XXMod[105X package, so this iterator was
introduced here. It used the operations [10XLatticeSubgroups(G)[110X and
[10XConjugacyClassesSubgroups(lat)[110X, and then iterates over the entries in these
classes.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xc3c3 := Group( (1,2,3), (4,5,6) );; [127X[104X
[4X[25Xgap>[125X [27Xiter := AllSubgroupsIterator( c3c3 );[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xwhile not IsDoneIterator(iter) do Print(NextIterator(iter),"\n"); od;[127X[104X
[4X[28XGroup( () )[128X[104X
[4X[28XGroup( [ (4,5,6) ] )[128X[104X
[4X[28XGroup( [ (1,2,3) ] )[128X[104X
[4X[28XGroup( [ (1,2,3)(4,5,6) ] )[128X[104X
[4X[28XGroup( [ (1,3,2)(4,5,6) ] )[128X[104X
[4X[28XGroup( [ (4,5,6), (1,2,3) ] )[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X7.2 [33X[0;0YOperations on iterators[133X[101X
[33X[0;0YThis section considers ways of producing an iterator from one or more
iterators. It may be that operations equivalent to these are available
elsewhere in the library -- if so, the ones here can be removed in due
course.[133X
[1X7.2-1 CartesianIterator[101X
[33X[1;0Y[29X[2XCartesianIterator[102X( [3Xiter1[103X, [3Xiter2[103X ) [32X operation[133X
[33X[0;0YThis iterator returns all pairs [22X[x,y][122X where [22Xx[122X is the output of a first
iterator and [22Xy[122X is the output of a second iterator.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xit1 := Iterator( [ 1, 2, 3 ] );;[127X[104X
[4X[25Xgap>[125X [27Xit2 := Iterator( [ 4, 5, 6 ] );;[127X[104X
[4X[25Xgap>[125X [27Xiter := CartesianIterator( it1, it2 );;[127X[104X
[4X[25Xgap>[125X [27Xwhile not IsDoneIterator(iter) do Print(NextIterator(iter),"\n"); od;[127X[104X
[4X[28X[ 1, 4 ][128X[104X
[4X[28X[ 1, 5 ][128X[104X
[4X[28X[ 1, 6 ][128X[104X
[4X[28X[ 2, 4 ][128X[104X
[4X[28X[ 2, 5 ][128X[104X
[4X[28X[ 2, 6 ][128X[104X
[4X[28X[ 3, 4 ][128X[104X
[4X[28X[ 3, 5 ][128X[104X
[4X[28X[ 3, 6 ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X7.2-2 UnorderedPairsIterator[101X
[33X[1;0Y[29X[2XUnorderedPairsIterator[102X( [3Xiter[103X ) [32X operation[133X
[33X[0;0YThis operation returns pairs [22X[x,y][122X where [22Xx,y[122X are output from a given
iterator [10Xiter[110X. Unlike the output from [10XCartesianIterator(iter,iter)[110X,
unordered pairs are returned. In the case [22XL = [1,2,3,...][122X the pairs are
ordered as [22X[1,1],[1,2],[2,2],[1,3],[2,3],[3,3],...[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XL := [6,7,8,9];;[127X[104X
[4X[25Xgap>[125X [27XiterL := IteratorList( L );; [127X[104X
[4X[25Xgap>[125X [27XpairsL := UnorderedPairsIterator( iterL );; [127X[104X
[4X[25Xgap>[125X [27Xwhile not IsDoneIterator(pairsL) do Print(NextIterator(pairsL),"\n"); od;[127X[104X
[4X[28X[ 6, 6 ][128X[104X
[4X[28X[ 6, 7 ][128X[104X
[4X[28X[ 7, 7 ][128X[104X
[4X[28X[ 6, 8 ][128X[104X
[4X[28X[ 7, 8 ][128X[104X
[4X[28X[ 8, 8 ][128X[104X
[4X[28X[ 6, 9 ][128X[104X
[4X[28X[ 7, 9 ][128X[104X
[4X[28X[ 8, 9 ][128X[104X
[4X[28X[ 9, 9 ][128X[104X
[4X[25Xgap>[125X [27Xiter4 := IteratorList( [ 4 ] );[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xpairs4 := UnorderedPairsIterator(iter4);[127X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XNextIterator( pairs4 );[127X[104X
[4X[28X[ 4, 4 ][128X[104X
[4X[25Xgap>[125X [27XIsDoneIterator( pairs4 );[127X[104X
[4X[28Xtrue[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
utils-0.93/doc/chap9_mj.html 0000644 0001751 0001751 00000026641 15105376105 015354 0 ustar runner runner
GAP (Utils) - Chapter 9: Web Downloads
The Download operation has been written by Thomas Breuer, incorporating a number of suggestions from Max Horn, for version 0.77 of Utils. It implements downloading a file from within GAP. It can use the IO or curlInterface packages, or wget or curl, if installed, and it can be extended with other download methods quite easily. It is envisaged that, once other packages have started to use it, and any problems have been addressed, that the functions will be transferred to the main GAP library.
9.1 Functions for downloading files from the web
9.1-1 Download
‣ Download( url[, opt] )
( function )
This function downloads the file with the web address url, which must be a string.
The result is a record which has at least the component success, with value true if the download was successful and false otherwise. In the former case, the component result is bound, whose value is a string that contains the contents of the downloaded file. In the latter case, the component error is bound, whose value is a string that describes the problem.
The function calls the methods stored in the global list Download_Methods until one of them is successful. Currently there are methods based on the GAP functions DownloadURL (curl: DownloadURL) and SingleHTTPRequest (IO: SingleHTTPRequest), and methods based on the external programs wget and curl.
An optional record opt can be given. The following components are supported.
maxTime
If this component is bound then its value must be a nonnegative integer \(n\), meaning that the function gives up after \(n\) seconds.
A zero value of \(n\) means that no timeout is set, the method will never give up in this case.
The default for \(n\) is given by the value of the user preference DownloadMaxTime (see 9.1-3).
target
If this component is bound then its value must be a string that is a local filename, and the function writes the downloaded contents to this file; the returned record does not have a result component in this case.
verifyCert
If this component is bound and has the value false then those download methods that are based on curl or wget will omit the check of the server's certificate.
The same effect is achieved for all Download calls by setting the user preference DownloadVerifyCertificate (see 9.1-2) to false and omitting the verifyCert component from opt.
The value true (the default) means that the server's certificate is checked in calls of Download (9.1-1), such that nothing gets downloaded if the certificate is invalid.
If the value is false then download methods are supposed to omit the check of the server's certificate (this may not be supported by all download methods).
One can set the value of the preference to be val via SetUserPreference (Reference: SetUserPreference), by calling SetUserPreference( "utils", "DownloadVerifyCertificate", val ), and access the current value via UserPreference (Reference: UserPreference), by calling UserPreference( "utils", "DownloadVerifyCertificate" ).
We recommend leaving this preference at its default value true. Sometimes it can be necessary to change it, e.g. to work around issues with old operating systems which may not be able to correctly verify new certificates. In general it is better to update such a system, but if that is not an option, then disabling certificate checks may be a good last resort.
9.1-3 User preference DownloadMaxTime
The value 0 (the default) means that no timeout is set in calls of Download (9.1-1). If the value is a positive integer \(n\) then those download methods that support a timeout will give up after \(n\) seconds.
One can set the value of the preference to be val via SetUserPreference (Reference: SetUserPreference), by calling SetUserPreference( "utils", "DownloadMaxTime", val ), and access the current value via UserPreference (Reference: UserPreference), by calling UserPreference( "utils", "DownloadMaxTime" ).
In June 2023 Hongyi Zhao asked in the Forum for a function to implement matrix decomposition into blocks. Such a function was then provided by Pedro GarcĂa-Sánchez. Hongyi Zhao then requested that the function be added to Utils. What is provided here is a revised version of the original solution, returning a list of decompositions.
This function is a partial inverse to the undocumented library operation DirectSumMat. So if L is the list of diagonal decompositions of a matrix M then each entry in L is a list of matrices, and the direct sum of each of these lists is equal to the original M.
In the following examples, M_6 is an obvious direct sum with 3 blocks. M_4 is an example with three decompositions, while M_8 = M_4 ⊕ M_4 has 16 decompositions (not listed).
The current method does not, however, catch all possible decompositions. In the following example the matrix M_5 has its third row and third column extirely zero, and the only decomposition found has a [0] factor. There are clearly two 2-factor decompositions with a 2-by-3 and a 3-by-2 factor, but these are not found at present.
[BCP97] Bosma, W., Cannon, J. and Playoust, C.,
The Magma algebra system. {I}. The user language,
J. Symbolic Comput.,
24 (3-4)
(1997),
235--265 pages
(
Computational algebra and number theory (London, 1993)}
https://doi.org/10.1006/jsco.1996.0125).
[GH16] Gutsche, S. and Horn, M.,
AutoDoc - Generate documentation from GAP source code (Version 2016.12.04)
(2016)
(
GAP package, https://github.com/gap-packages/AutoDoc).
[WAOU17] Wensley, C. D., Alp, M., Odabas, A. and Uslu, E. O.,
XMod - Crossed Modules and Cat1-groups in GAP (Version 2.64)
(2017)
(
GAP package, https://github.com/gap-packages/xmod).
These functions have been transferred from package ResClasses.
They take a list \(L\) of length \(n\) and output the quotients \(L[i]/L[i-1]\) of consecutive entries in \(L\). An error is returned if an entry is zero.
This function has been transferred from package RCWA.
SearchCycle is a tool to find likely cycles in lists. What, precisely, a cycle is, is deliberately fuzzy here, and may possibly even change. The idea is that the beginning of the list may be anything, following that the same pattern needs to be repeated several times in order to be recognized as a cycle.
This function has been transferred from package ResClasses.
It returns a random unordered \(k\)-tuple of distinct elements of a set \(S\).
gap>## "6 aus 49" is a common lottery in Germanygap>RandomCombination( [1..49], 6 );
[ 2, 16, 24, 26, 37, 47 ]
3.2 Distinct and Common Representatives
3.2-1 DistinctRepresentatives
‣ DistinctRepresentatives( list )
( operation )
‣ CommonRepresentatives( list )
( operation )
‣ CommonTransversal( grp, subgrp )
( operation )
‣ IsCommonTransversal( grp, subgrp, list )
( operation )
These operations have been transferred from package XMod.
They deal with lists of subsets of \([1 \ldots n]\) and construct systems of distinct and common representatives using simple, non-recursive, combinatorial algorithms.
When \(L\) is a set of \(n\) subsets of \([1 \ldots n]\) and the Hall condition is satisfied (the union of any \(k\) subsets has at least \(k\) elements), a set of DistinctRepresentatives exists.
When \(J,K\) are both lists of \(n\) sets, the operation CommonRepresentatives returns two lists: the set of representatives, and a permutation of the subsets of the second list.
The operation CommonTransversal may be used to provide a common transversal for the sets of left and right cosets of a subgroup \(H\) of a group \(G\), although a greedy algorithm is usually quicker.
This function has been transferred from package RCWA.
The function AllSmoothIntegers(maxp,maxn) returns the list of all positive integers less than or equal to maxn whose prime factors are all in the list L = {p ~|~ p leqslant maxp, p~mboxprime }.
In the alternative form, when L is a list of primes, the function returns the list of all positive integers whose prime factors lie in L.
This function has been transferred from package RCWA.
The command AllProducts(L,k) returns the list of all products of k entries of the list L. Note that every ordering of the entries is used so that, in the commuting case, there are bound to be repetitions.
This function has been transferred from package RCWA.
For a positive integer n and a set of positive integers S, this function returns the list of partitions of n into distinct elements of S. Unlike RestrictedPartitions, no repetitions are allowed.
This function has been transferred from package RCWA.
The function NextProbablyPrimeInt(n) does the same as NextPrimeInt(n) except that for reasons of performance it tests numbers only for IsProbablyPrimeInt(n) instead of IsPrimeInt(n). For large n, this function is much faster than NextPrimeInt(n)
gap>n := 2^251;
3618502788666131106986593281521497120414687020801267626233049500247285301248
gap>NextProbablyPrimeInt( n );
3618502788666131106986593281521497120414687020801267626233049500247285301313
gap>time;
1
gap>NextPrimeInt( n );
3618502788666131106986593281521497120414687020801267626233049500247285301313
gap>time;
213
4.1-5 PrimeNumbersIterator
‣ PrimeNumbersIterator( [chunksize] )
( function )
This function has been transferred from package RCWA.
This function returns an iterator which runs over the prime numbers n ascending order; it takes an optional argument chunksize which specifies the length of the interval which is sieved in one go (the default is 10^7), and which can be used to balance runtime vs. memory consumption. It is assumed that chunksize is larger than any gap between two consecutive primes within the range one intends to run the iterator over.
gap>iter := PrimeNumbersIterator();;gap>for i in [1..100] do p := NextIterator(iter); od;gap>p;
541
gap>sum := 0;;gap>## "prime number race" 1 vs. 3 mod 4gap>for p in PrimeNumbersIterator() do > if p <> 2 then sum := sum + E(4)^(p-1); fi;> if sum > 0 then break; fi;> od;gap>p;
26861
utils-0.93/doc/chap11.txt 0000644 0001751 0001751 00000010414 15105376105 014601 0 ustar runner runner
[1X11 [33X[0;0YObsolete functions[133X[101X
[1X11.1 [33X[0;0YOperations from AutoDoc[133X[101X
[33X[0;0YThe file functions [10XFindMatchingFiles[110X and [10XCreateDirIfMissing[110X were copied from
package [5XAutoDoc[105X where they are named [10XAutoDoc_FindMatchingFiles[110X and
[10XAutoDoc_CreateDirIfMissing[110X.[133X
[33X[0;0YThe string function [10XStringDotSuffix[110X was also copied from package [5XAutoDoc[105X,
where it is named [10XAUTODOC_GetSuffix[110X.[133X
[33X[0;0YThe function [10XSetIfMissing[110X was also transferred from package [5XAutoDoc[105X, where
it is called [10XAUTODOC_SetIfMissing[110X. It writes into a record provided the
position is not yet bound.[133X
[33X[0;0YAs from version 0.61, all these functions became obsolete in [5XUtils[105X, but
continue to be defined in [5XAutoDoc[105X.[133X
[1X11.2 [33X[0;0YFunctions for printing[133X[101X
[33X[0;0YThe function [10XPrintOneItemPerLine[110X was used to prints lists vertically, rather
than horizontally. Since a very similar result may be achieved using the [5XGAP[105X
library functions [10XPerform[110X and [10XDisplay[110X, this function became obsolete in
version 0.61.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xs3 := SymmetricGroup( 3 );; [127X[104X
[4X[25Xgap>[125X [27XL := KnownPropertiesOfObject( GeneratorsOfGroup( s3 ) );;[127X[104X
[4X[25Xgap>[125X [27XPerform( L, Display );[127X[104X
[4X[28XIsFinite[128X[104X
[4X[28XIsSmallList[128X[104X
[4X[28XIsGeneratorsOfMagmaWithInverses[128X[104X
[4X[28XIsGeneratorsOfSemigroup[128X[104X
[4X[28XIsSubsetLocallyFiniteGroup[128X[104X
[4X[25Xgap>[125X [27XPerform( s3, Display ); [127X[104X
[4X[28X()[128X[104X
[4X[28X(2,3)[128X[104X
[4X[28X(1,3)[128X[104X
[4X[28X(1,3,2)[128X[104X
[4X[28X(1,2,3)[128X[104X
[4X[28X(1,2)[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X11.3 [33X[0;0YOther obsolete functions[133X[101X
[1X11.3-1 [33X[0;0YApplicable Methods[133X[101X
[33X[0;0YThe function [10XPrintApplicableMethod[110X, which was included in versions from 0.41
to 0.58, has been removed since it was considered superfluous. The example
shows how to print out a function.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 1, 1 );[127X[104X
[4X[28X#I Searching Method for IsCyclic with 1 arguments:[128X[104X
[4X[28X#I Total: 7 entries[128X[104X
[4X[28X#I Method 4: ``IsCyclic'' at /Applications/gap/gap4r9/lib/grp.gi:30 , value: [128X[104X
[4X[28X36[128X[104X
[4X[28Xfunction( G ) ... end[128X[104X
[4X[25Xgap>[125X [27XPrint( last );[127X[104X
[4X[28Xfunction ( G )[128X[104X
[4X[28X if Length( GeneratorsOfGroup( G ) ) = 1 then[128X[104X
[4X[28X return true;[128X[104X
[4X[28X else[128X[104X
[4X[28X TryNextMethod();[128X[104X
[4X[28X fi;[128X[104X
[4X[28X return;[128X[104X
[4X[28Xend[128X[104X
[4X[25Xgap>[125X [27XApplicableMethod( IsCyclic, [ Group((1,2,3),(4,5)) ], 0, 3 );[127X[104X
[4X[28Xfunction( <1 unnamed arguments> ) ... end[128X[104X
[4X[25Xgap>[125X [27XPrint( last ); [127X[104X
[4X[28Xfunction ( <> )[128X[104X
[4X[28X <>[128X[104X
[4X[28Xend[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X11.3-2 [33X[0;0YExponentOfPrime[133X[101X
[33X[0;0YThe function [10XExponentOfPrime[110X was originally transferred from package [5XRCWA[105X.
The command [10XExponentOfPrime([3Xn[103X[10X,[3Xp[103X[10X)[110X returned the exponent of the prime [3Xp[103X in the
prime factorization of [3Xn[103X.[133X
[33X[0;0YSince the [5XGAP[105X function [10XPValuation[110X produces the same results, and does so
more quickly, this function has been made obsolete.[133X
utils-0.93/doc/chap5.html 0000644 0001751 0001751 00000103725 15105376105 014661 0 ustar runner runner
GAP (Utils) - Chapter 5: Groups and homomorphisms
This method has been transferred from package ResClasses.
It provides a method for Comm when the argument is a list (enclosed in square brackets), and calls the function LeftNormedComm.
gap>Comm( [ (1,2), (2,3) ] );
(1,2,3)
gap>Comm( [(1,2),(2,3),(3,4),(4,5),(5,6)] );
(1,5,6)
gap>Comm(Comm(Comm(Comm((1,2),(2,3)),(3,4)),(4,5)),(5,6)); ## the same
(1,5,6)
5.1-2 IsCommuting
‣ IsCommuting( a, b )
( operation )
This function has been transferred from package ResClasses.
It tests whether two elements in a group commute.
gap>D12 := DihedralGroup( 12 );
<pc group of size 12 with 3 generators>
gap>SetName( D12, "D12" ); gap>a := D12.1;; b := D12.2;; gap>IsCommuting( a, b );
false
5.1-3 ListOfPowers
‣ ListOfPowers( g, exp )
( operation )
This function has been transferred from package RCWA.
The operation ListOfPowers(g,exp) returns the list [g,g^2,...,g^exp] of powers of the element g.
Since GAP uses right actions by default, the library contains the operation RightCoset(U,g) for constructing the right coset Ug of a subgroup U ≤ G and an element g â G. It has been noted in the reference manual that, by inverting all the elements in Ug, the left coset g^-1U is obtained.
Just for the sake of completeness, from August 2022 this package provides the operation LeftCoset(g,U) for constructing the left coset gU. Users are strongly recommended to continue to use RightCoset for all serious calculations, since left cosets have a much simpler implementation and do not behave exactly like right cosets.
The methods for left cosets which are provided generally work by converting gU to Ug^-1; applying the equivalent method for right cosets; and, if necessary, converting back again to left cosets.
G acts on left cosets by OnLeftInverse: (gU)^g_0 = g_0^-1*(gU) = (g_0^-1g)U.
The inverse of the left coset gU is the right coset Ug^-1, and conversely. This is an abuse of the attribute Inverse, since the standard requirement, that x*x^-1 is an identity, does not hold.
This function has been transferred from package RCWA.
It constructs a group homomorphism which maps the generators of G to those of H. Its intended use is when G is a free group, and a warning is printed when this is not the case. Note that anything may happen if the resulting map is not a homomorphism!
gap>G := Group( (1,2,3), (3,4,5), (5,6,7), (7,8,9) );;gap>phi := EpimorphismByGenerators( FreeGroup("a","b","c","d"), G );
[ a, b, c, d ] -> [ (1,2,3), (3,4,5), (5,6,7), (7,8,9) ]
gap>PreImagesRepresentativeNC( phi, (1,2,3,4,5,6,7,8,9) );
d*c*b*a
gap>a := G.1;; b := G.2;; c := G.3;; d := G.4;;gap>d*c*b*a;
(1,2,3,4,5,6,7,8,9)
gap>## note that it is easy to produce nonsense: gap>epi := EpimorphismByGenerators( Group((1,2,3)), Group((8,9)) );
Warning: calling GroupHomomorphismByImagesNC without checks
[ (1,2,3) ] -> [ (8,9) ]
gap>IsGroupHomomorphism( epi );
true
gap>Image( epi, (1,2,3) );
()
gap>Image( epi, (1,3,2) );
(8,9)
5.3-2 Pullback
‣ Pullback( hom1, hom2 )
( operation )
‣ PullbackInfo( G )
( attribute )
If Ď•_1 : G_1 -> H and Ď•_2 : G_2 -> H are two group homomorphisms with the same range, then their pullback is the subgroup of G_1 Ă— G_2 consisting of those elements (g_1,g_2) such that Ď•_1 g_1 = Ď•_2 g_2.
The attribute PullbackInfo of a pullback group P is similar to DirectProductInfo for a direct product of groups. Its value is a record with the following components:
directProduct
the direct product G_1 Ă— G_2, and
projections
a list with the two projections onto G_1 and G_2.
There are no embeddings in this record, but it is possible to use the embeddings into the direct product, see Embedding (Reference: Embedding).
Let G1 and G2 be two groups, Z1 be a central subgroup of G1, and Phi be an isomorphism from Z1 to a central subgroup of G2. The central product defined by these arguments is the factor group of the direct product of G1 and G2 by the central subgroup { (z, (Phi(z))^-1) : z â Z1 }.
The attribute CentralProductInfo of a group G that has been created by CentralProduct is similar to PullbackInfo (5.3-2) for pullback groups. Its value is a record with the following components.
projection
the epimorphism from the direct product of G1 and G2 to G, and
phi
the map Phi.
Note that one can access the direct product as the Source (Reference: Source) value of the projection map, and one can access G1 and G2 as the two embeddings of this direct product, see Embedding (Reference: Embedding).
An endomorphism f : G -> G is idempotent if f^2=f. It has an image R leqslant G; is the identity map when restricted to R; and has a kernel N which has trivial intersection with R and has size |G|/|R|.
The operation IdempotentEndomorphismsWithImage(genG,R) returns a list of the images of the generating set genG of a group G under the idempotent endomorphisms with image R.
The attribute IdempotentEndomorphismsData(G) returns a record data with fields data.gens, a fixed generating set for G, and data.images a list of the non-empty outputs of IdempotentEndomorphismsWithImage(genG,R) obtained by iterating over all subgroups of G.
The operation IdempotentEndomorphisms(G) returns the list of these mappings obtained using IdempotentEndomorphismsData(G). The first of these is the zero map, the second is the identity.
The quaternion group q8 is an example of a group with a tail: there is only one subgroup in the lattice which covers the identity subgroup. The only idempotent isomorphisms of such groups are the identity mapping and the zero mapping because the only pairs N,R are the whole group and the identity subgroup.
gap>q8 := QuaternionGroup( 8 );;gap>IdempotentEndomorphisms( q8 );
[ [ x, y ] -> [ <identity> of ..., <identity> of ... ], [ x, y ] -> [ x, y ] ]
5.3-5 DirectProductOfFunctions
‣ DirectProductOfFunctions( G, H, f1, f2 )
( operation )
Given group homomorphisms f_1 : G_1 -> G_2 and f_2 : H_1 -> H_2, this operation return the product homomorphism f_1 Ă— f_2 : G_1 Ă— G_2 -> H_1 Ă— H_2.
Let A_1,A_2 be groups of automorphism of groups G_1,G_2 respectively. The output of this function is a group A_1 Ă— A_2 of automorphisms of G_1 Ă— G_2.
utils-0.93/doc/intro.xml 0000644 0001751 0001751 00000011663 15105376105 014647 0 ustar runner runner
Introduction
The &Utils; package provides a space for utility functions from a variety
of &GAP; packages to be collected together into a single package.
In this way it is hoped that they will become more visible
to other package authors.
This package was first distributed as part of the &GAP; 4.8.2 distribution.
The package is loaded with the command
LoadPackage( "utils" );
]]>
Functions have been transferred from the following packages:
Conversion of a &GAP; group to a &Magma; output string, taken from various
sources including other.gi in the main library.
Transfer is complete (for now) for functions from the following packages:
&AutoDoc; (with function names changed);
&ResClasses; ;
&RCWA; ;
&XMod; .
The package may be obtained either as a compressed .tar file
or as a .zip file, utils-version_number.tar.gz,
by ftp from one of the following sites:
the &Utils; GitHub release site:
https://gap-packages.github.io/utils/.
any &GAP; archive, e.g.
https://www.gap-system.org/Packages/packages.html;
GitHub repository
The package also has a GitHub repository at:
https://github.com/gap-packages/utils.
Once the package is loaded, the manual doc/manual.pdf
can be found in the documentation folder.
The html versions, with or without &MathJax;,
may be rebuilt as follows:
ReadPackage( "utils", "makedoc.g" );
]]>
It is possible to check that the package has been installed correctly
by running the test files (which terminates the &GAP; session):
ReadPackage( "utils", "tst/testall.g" );
Architecture: . . . . .
testing: . . . . .
. . .
#I No errors detected while testing
]]>
Note that functions listed in this manual that are currently
in the process of being transferred
are only read from the source package &Home; (say),
and so can only be used if &Home; has already been loaded.
There are no such functions in transition at present.
Information for package authors
A function (or collection of functions) is suitable for transfer
from a package &Home; to &Utils;
if the following conditions are satisfied.
The function is sufficiently non-specialised so that it might be of use
to other authors.
The function does not depend on the remaining functions in &Home;
The function does not do what can already be done with a &GAP; library function.
Documentation of the function and test examples are available.
When there is more than one active author of &Home;, they should all be aware
(and content) that the transfer is taking place.
Authors of packages may be reluctant to let go of their utility functions.
The following principles may help to reassure them.
(Suggestions for more items here are welcome.)
A function that has been transferred to &Utils; will not be changed
without the approval of the original author.
The current package maintainer has every intention of continuing
to maintain &Utils;.
In the event that this proves impossible, the &GAP; development team
will surely find someone to take over.
Function names will not be changed unless specifically requested by
&Home;'s author(s) or unless they have the form
HOME_FunctionName.
In order to speed up the transfer process, only functions from one package
will be in transition at any given time.
Hopefully a week or two will suffice for most packages.
Any package author who transfers a function to &Utils; will become
an author of &Utils;.
(In truth, &Utils; does not have authors,
just a large number of contributors.)
The process for transferring utility functions from &Home; to &Utils;
is described in Chapter .
utils-0.93/doc/chap3.txt 0000644 0001751 0001751 00000024016 15105376105 014525 0 ustar runner runner
[1X3 [33X[0;0YLists, Sets and Strings[133X[101X
[1X3.1 [33X[0;0YFunctions for lists[133X[101X
[1X3.1-1 DifferencesList[101X
[33X[1;0Y[29X[2XDifferencesList[102X( [3XL[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XResClasses[105X.[133X
[33X[0;0YIt takes a list [22XL[122X of length [22Xn[122X and outputs the list of length [22Xn-1[122X containing
all the differences [22XL[i]-L[i-1][122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XList( [1..12], n->n^3 );[127X[104X
[4X[28X[ 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728 ][128X[104X
[4X[25Xgap>[125X [27XDifferencesList( last );[127X[104X
[4X[28X[ 7, 19, 37, 61, 91, 127, 169, 217, 271, 331, 397 ][128X[104X
[4X[25Xgap>[125X [27XDifferencesList( last );[127X[104X
[4X[28X[ 12, 18, 24, 30, 36, 42, 48, 54, 60, 66 ][128X[104X
[4X[25Xgap>[125X [27XDifferencesList( last );[127X[104X
[4X[28X[ 6, 6, 6, 6, 6, 6, 6, 6, 6 ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X3.1-2 QuotientsList[101X
[33X[1;0Y[29X[2XQuotientsList[102X( [3XL[103X ) [32X function[133X
[33X[1;0Y[29X[2XFloatQuotientsList[102X( [3XL[103X ) [32X function[133X
[33X[0;0YThese functions have been transferred from package [5XResClasses[105X.[133X
[33X[0;0YThey take a list [22XL[122X of length [22Xn[122X and output the quotients [22XL[i]/L[i-1][122X of
consecutive entries in [22XL[122X. An error is returned if an entry is zero.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XList( [0..10], n -> Factorial(n) );[127X[104X
[4X[28X[ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ][128X[104X
[4X[25Xgap>[125X [27XQuotientsList( last );[127X[104X
[4X[28X[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ][128X[104X
[4X[25Xgap>[125X [27XL := [ 1, 3, 5, -1, -3, -5 ];;[127X[104X
[4X[25Xgap>[125X [27XQuotientsList( L );[127X[104X
[4X[28X[ 3, 5/3, -1/5, 3, 5/3 ][128X[104X
[4X[25Xgap>[125X [27XFloatQuotientsList( L );[127X[104X
[4X[28X[ 3., 1.66667, -0.2, 3., 1.66667 ][128X[104X
[4X[25Xgap>[125X [27XQuotientsList( [ 2, 1, 0, -1, -2 ] );[127X[104X
[4X[28X[ 1/2, 0, fail, 2 ][128X[104X
[4X[25Xgap>[125X [27XFloatQuotientsList( [1..10] );[127X[104X
[4X[28X[ 2., 1.5, 1.33333, 1.25, 1.2, 1.16667, 1.14286, 1.125, 1.11111 ][128X[104X
[4X[25Xgap>[125X [27XProduct( last );[127X[104X
[4X[28X10. [128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X3.1-3 SearchCycle[101X
[33X[1;0Y[29X[2XSearchCycle[102X( [3XL[103X ) [32X operation[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0Y[10XSearchCycle[110X is a tool to find likely cycles in lists. What, precisely, a
[13Xcycle[113X is, is deliberately fuzzy here, and may possibly even change. The idea
is that the beginning of the list may be anything, following that the same
pattern needs to be repeated several times in order to be recognized as a
cycle.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XL := [1..20];; L[1]:=13;; [127X[104X
[4X[25Xgap>[125X [27Xfor i in [1..19] do [127X[104X
[4X[25X>[125X [27X if IsOddInt(L[i]) then L[i+1]:=3*L[i]+1; else L[i+1]:=L[i]/2; fi;[127X[104X
[4X[25X>[125X [27X od; [127X[104X
[4X[25Xgap>[125X [27XL; [127X[104X
[4X[28X[ 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4 ][128X[104X
[4X[25Xgap>[125X [27XSearchCycle( L ); [127X[104X
[4X[28X[ 1, 4, 2 ][128X[104X
[4X[25Xgap>[125X [27Xn := 1;; L := [n];;[127X[104X
[4X[25Xgap>[125X [27Xfor i in [1..100] do n:=(n^2+1) mod 1093; Add(L,n); od;[127X[104X
[4X[25Xgap>[125X [27XL; [127X[104X
[4X[28X[ 1, 2, 5, 26, 677, 363, 610, 481, 739, 715, 795, 272, 754, 157, 604, 848, [128X[104X
[4X[28X 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271, [128X[104X
[4X[28X 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521, [128X[104X
[4X[28X 378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, [128X[104X
[4X[28X 754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, [128X[104X
[4X[28X 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, [128X[104X
[4X[28X 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004 ][128X[104X
[4X[25Xgap>[125X [27XC := SearchCycle( L );[127X[104X
[4X[28X[ 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754 ][128X[104X
[4X[25Xgap>[125X [27XP := Positions( L, 157 );[127X[104X
[4X[28X[ 14, 26, 38, 50, 62, 74, 86, 98 ][128X[104X
[4X[25Xgap>[125X [27XLength( C ); DifferencesList( P );[127X[104X
[4X[28X12[128X[104X
[4X[28X[ 12, 12, 12, 12, 12, 12, 12 ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X3.1-4 RandomCombination[101X
[33X[1;0Y[29X[2XRandomCombination[102X( [3XS[103X, [3Xk[103X ) [32X operation[133X
[33X[0;0YThis function has been transferred from package [5XResClasses[105X.[133X
[33X[0;0YIt returns a random unordered [22Xk[122X-tuple of distinct elements of a set [22XS[122X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27X## "6 aus 49" is a common lottery in Germany[127X[104X
[4X[25Xgap>[125X [27XRandomCombination( [1..49], 6 ); [127X[104X
[4X[28X[ 2, 16, 24, 26, 37, 47 ][128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X3.2 [33X[0;0YDistinct and Common Representatives[133X[101X
[1X3.2-1 DistinctRepresentatives[101X
[33X[1;0Y[29X[2XDistinctRepresentatives[102X( [3Xlist[103X ) [32X operation[133X
[33X[1;0Y[29X[2XCommonRepresentatives[102X( [3Xlist[103X ) [32X operation[133X
[33X[1;0Y[29X[2XCommonTransversal[102X( [3Xgrp[103X, [3Xsubgrp[103X ) [32X operation[133X
[33X[1;0Y[29X[2XIsCommonTransversal[102X( [3Xgrp[103X, [3Xsubgrp[103X, [3Xlist[103X ) [32X operation[133X
[33X[0;0YThese operations have been transferred from package [5XXMod[105X.[133X
[33X[0;0YThey deal with lists of subsets of [22X[1 ... n][122X and construct systems of
distinct and common representatives using simple, non-recursive,
combinatorial algorithms.[133X
[33X[0;0YWhen [22XL[122X is a set of [22Xn[122X subsets of [22X[1 ... n][122X and the Hall condition is
satisfied (the union of any [22Xk[122X subsets has at least [22Xk[122X elements), a set of
[10XDistinctRepresentatives[110X exists.[133X
[33X[0;0YWhen [22XJ,K[122X are both lists of [22Xn[122X sets, the operation [10XCommonRepresentatives[110X
returns two lists: the set of representatives, and a permutation of the
subsets of the second list.[133X
[33X[0;0YThe operation [10XCommonTransversal[110X may be used to provide a common transversal
for the sets of left and right cosets of a subgroup [22XH[122X of a group [22XG[122X, although
a greedy algorithm is usually quicker.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XJ := [ [1,2,3], [3,4], [3,4], [1,2,4] ];;[127X[104X
[4X[25Xgap>[125X [27XDistinctRepresentatives( J );[127X[104X
[4X[28X[ 1, 3, 4, 2 ][128X[104X
[4X[25Xgap>[125X [27XK := [ [3,4], [1,2], [2,3], [2,3,4] ];;[127X[104X
[4X[25Xgap>[125X [27XCommonRepresentatives( J, K );[127X[104X
[4X[28X[ [ 3, 3, 3, 1 ], [ 1, 3, 4, 2 ] ][128X[104X
[4X[25Xgap>[125X [27Xd16 := DihedralGroup( IsPermGroup, 16 ); [127X[104X
[4X[28XGroup([ (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) ])[128X[104X
[4X[25Xgap>[125X [27XSetName( d16, "d16" );[127X[104X
[4X[25Xgap>[125X [27Xc4 := Subgroup( d16, [ d16.1^2 ] ); [127X[104X
[4X[28XGroup([ (1,3,5,7)(2,4,6,8) ])[128X[104X
[4X[25Xgap>[125X [27XSetName( c4, "c4" );[127X[104X
[4X[25Xgap>[125X [27XRightCosets( d16, c4 );[127X[104X
[4X[28X[ RightCoset(c4,()), RightCoset(c4,(2,8)(3,7)(4,6)), RightCoset(c4,(1,8,7,6,5,[128X[104X
[4X[28X 4,3,2)), RightCoset(c4,(1,8)(2,7)(3,6)(4,5)) ][128X[104X
[4X[25Xgap>[125X [27Xtrans := CommonTransversal( d16, c4 );[127X[104X
[4X[28X[ (), (2,8)(3,7)(4,6), (1,2,3,4,5,6,7,8), (1,2)(3,8)(4,7)(5,6) ][128X[104X
[4X[25Xgap>[125X [27XIsCommonTransversal( d16, c4, trans );[127X[104X
[4X[28Xtrue[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X3.3 [33X[0;0YFunctions for strings[133X[101X
[1X3.3-1 BlankFreeString[101X
[33X[1;0Y[29X[2XBlankFreeString[102X( [3Xobj[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XResClasses[105X.[133X
[33X[0;0YThe result of [10XBlankFreeString( obj );[110X is a composite of the functions
[10XString( obj )[110X and [10XRemoveCharacters( obj, " " );[110X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xgens := GeneratorsOfGroup( DihedralGroup(12) );[127X[104X
[4X[28X[ f1, f2, f3 ][128X[104X
[4X[25Xgap>[125X [27XString( gens ); [127X[104X
[4X[28X"[ f1, f2, f3 ]"[128X[104X
[4X[25Xgap>[125X [27XBlankFreeString( gens ); [127X[104X
[4X[28X"[f1,f2,f3]"[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
utils-0.93/doc/bib.xml 0000644 0001751 0001751 00000006312 15105376105 014243 0 ustar runner runner
SebastianGutscheMaxHorn<C>AutoDoc - Generate documentation from GAP source code (Version 2016.12.04)</C>2016
GAP package, https://github.com/gap-packages/AutoDocFrankLübeckMaxNeunhöffer<C>GAPDoc (Version 1.6)</C>RWTH Aachen2017
GAP package,
https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc/index.htmlMaxHorn<C>GitHubPagesForGAP - Template for easily using GitHub Pages within GAP packages (Version 0.2)</C>2017
GAP package, https://gap-system.github.io/GitHubPagesForGAP/
http://magma.maths.usyd.edu.au/magma/
WiebBosmaJohnCannonCatherinePlayoust<C>The Magma algebra system. {I}. The user language</C>
Computational algebra and number theory (London, 1993)}
https://doi.org/10.1006/jsco.1996.0125J. Symbolic Comput.2419973-4235--2650747-717168Q40MR148447810.1006/jsco.1996.0125StefanKohl<C>RCWA - Residue-Class-Wise Affine Groups (Version 4.5.1)</C>2017
GAP package, https://stefan-kohl.github.io/rcwa.htmlStefanKohl<C>ResClasses - Set-Theoretic Computations with Residue Classes (Version 4.6.0)</C>2017
GAP package, https://stefan-kohl.github.io/resclasses.htmlChris D.WensleyMuratAlpAlperOdabasEnver OnderUslu<C>XMod - Crossed Modules and Cat1-groups in GAP (Version 2.64)</C>2017
GAP package, https://github.com/gap-packages/xmod
utils-0.93/doc/chap7.html 0000644 0001751 0001751 00000026622 15105376105 014663 0 ustar runner runner
GAP (Utils) - Chapter 7: Iterators
7.1 Some iterators for groups and their isomorphisms
The motivation for adding these operations is partly to give a simple example of an iterator for a list that does not yet exist, and need not be created.
7.1-1 AllIsomorphismsIterator
‣ AllIsomorphismsIterator( G, H )
( operation )
‣ AllIsomorphismsNumber( G, H )
( operation )
‣ AllIsomorphisms( G, H )
( operation )
The main GAP library contains functions producing complete lists of group homomorphisms such as AllHomomorphisms; AllEndomorphisms and AllAutomorphisms. Here we add the missing AllIsomorphisms(G,H) for a list of isomorphisms from G to H. The method is simple -- find one isomorphism G -> H and compose this with all the automorphisms of G. In all these cases it may not be desirable to construct a list of homomorphisms, but just implement an iterator, and that is what is done here. The operation AllIsomorphismsNumber returns the number of isomorphisms iterated over (this is, of course, just the order of the automorphisms group). The operation AllIsomorphisms produces the list or isomorphisms.
The manual entry for the operation AllSubgroups states that it is only intended to be used on small examples in a classroom situation. Access to all subgroups was required by the XMod package, so this iterator was introduced here. It used the operations LatticeSubgroups(G) and ConjugacyClassesSubgroups(lat), and then iterates over the entries in these classes.
This section considers ways of producing an iterator from one or more iterators. It may be that operations equivalent to these are available elsewhere in the library -- if so, the ones here can be removed in due course.
7.2-1 CartesianIterator
‣ CartesianIterator( iter1, iter2 )
( operation )
This iterator returns all pairs [x,y] where x is the output of a first iterator and y is the output of a second iterator.
This operation returns pairs [x,y] where x,y are output from a given iterator iter. Unlike the output from CartesianIterator(iter,iter), unordered pairs are returned. In the case L = [1,2,3,...] the pairs are ordered as [1,1],[1,2],[2,2],[1,3],[2,3],[3,3],....
utils-0.93/doc/chap10.txt 0000644 0001751 0001751 00000015030 15105376105 014577 0 ustar runner runner
[1X10 [33X[0;0YVarious other functions[133X[101X
[1X10.1 [33X[0;0YFile operations[133X[101X
[1X10.1-1 Log2HTML[101X
[33X[1;0Y[29X[2XLog2HTML[102X( [3Xfilename[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YThis function converts the [5XGAP[105X logfile [11Xfilename[111X to HTML. It appears that the
logfile should be in your current directory. The extension of the input file
must be [11X*.log[111X. The name of the output file is the same as the one of the
input file except that the extension [11X*.log[111X is replaced by [11X*.html[111X. There is a
sample CSS file in [11Xutils/doc/gaplog.css[111X, which you can adjust to your taste.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XLogTo( "triv.log" );[127X[104X
[4X[25Xgap>[125X [27Xa := 33^5;[127X[104X
[4X[28X39135393[128X[104X
[4X[25Xgap>[125X [27XLogTo(); [127X[104X
[4X[25Xgap>[125X [27XLog2HTML( "triv.log" ); [127X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X10.2 [33X[0;0YLaTeX strings[133X[101X
[1X10.2-1 IntOrOnfinityToLaTeX[101X
[33X[1;0Y[29X[2XIntOrOnfinityToLaTeX[102X( [3Xn[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XResClasses[105X.[133X
[33X[0;0Y[10XIntOrInfinityToLaTeX(n)[110X returns the LaTeX string for [3Xn[103X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XIntOrInfinityToLaTeX( 10^3 );[127X[104X
[4X[28X"1000"[128X[104X
[4X[25Xgap>[125X [27XIntOrInfinityToLaTeX( infinity );[127X[104X
[4X[28X"\\infty"[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X10.2-2 LaTeXStringFactorsInt[101X
[33X[1;0Y[29X[2XLaTeXStringFactorsInt[102X( [3Xn[103X ) [32X function[133X
[33X[0;0YThis function has been transferred from package [5XRCWA[105X.[133X
[33X[0;0YIt returns the prime factorization of the integer [22Xn[122X as a string in LaTeX
format.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27XLaTeXStringFactorsInt( Factorial(12) );[127X[104X
[4X[28X"2^{10} \\cdot 3^5 \\cdot 5^2 \\cdot 7 \\cdot 11"[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X10.3 [33X[0;0YConversion to [22XMagma[122X[101X[1X strings[133X[101X
[1X10.3-1 ConvertToMagmaInputString[101X
[33X[1;0Y[29X[2XConvertToMagmaInputString[102X( [3Xarg[103X ) [32X function[133X
[33X[0;0YThe function [10XConvertToMagmaInputString( obj [, str] )[110X attempts to output a
string [10Xs[110X which can be read into [22XMagma[122X [BCP97] so as to produce the same
group in that computer algebra system. In the second form the user specifies
the name of the resulting object, so that the output string has the form
[10X"str := ..."[110X.[133X
[33X[0;0YWhen [10Xobj[110X is a permutation group, the operation [10XPermGroupToMagmaFormat(obj)[110X
is called. This function has been taken from [11Xother.gi[111X in the main library
where it was called [10XMagmaInputString[110X.[133X
[33X[0;0YWhen [10Xobj[110X is a pc-group, the operation [10XPcGroupToMagmaFormat(obj)[110X is called.
This function was private code of Max Horn.[133X
[33X[0;0YWhen [10Xobj[110X is a matrix group over a finite field, the operation
[10XMatrixGroupToMagmaFormat(obj)[110X is called. This function is a modification of
private code of Frank LĂĽbeck.[133X
[33X[0;0YHopefully code for other types of group will be added in due course.[133X
[33X[0;0YThese functions should be considered [13Xexperimental[113X, and more testing is
desirable.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27X## permutation groups[127X[104X
[4X[25Xgap>[125X [27XConvertToMagmaInputString( Group( (1,2,3,4,5), (3,4,5) ) );[127X[104X
[4X[28X"PermutationGroup<5|(1,2,3,4,5),\n(3,4,5)>;\n"[128X[104X
[4X[25Xgap>[125X [27XConvertToMagmaInputString( Group( (1,2,3,4,5) ), "c5" ); [127X[104X
[4X[28X"c5 := PermutationGroup<5|(1,2,3,4,5)>;\n"[128X[104X
[4X[25Xgap>[125X [27X## pc-group[127X[104X
[4X[25Xgap>[125X [27XConvertToMagmaInputString( DihedralGroup( IsPcGroup, 10 ) );[127X[104X
[4X[28X"PolycyclicGroup< f1,f2 |\nf1^2,\nf2^5,\nf2^f1 = f2^4\n>;\n"[128X[104X
[4X[25Xgap>[125X [27X## fp-group[127X[104X
[4X[25Xgap>[125X [27XF2 := FreeGroup( 2 );;[127X[104X
[4X[25Xgap>[125X [27Xf := F2.1;; g := F2.2;;[127X[104X
[4X[25Xgap>[125X [27Xrelq8 := [ f^4, g^4, f*g*f*g^-1, f^2*g^2 ];; [127X[104X
[4X[25Xgap>[125X [27Xq8 := F2/relq8;; [127X[104X
[4X[25Xgap>[125X [27XConvertToMagmaInputString( q8 );[127X[104X
[4X[28Xno conversion function yet available for fp-groups[128X[104X
[4X[28Xfail[128X[104X
[4X[25Xgap>[125X [27X## matrix group[127X[104X
[4X[25Xgap>[125X [27XM := GL(2,5);; Size(M); [127X[104X
[4X[28X480[128X[104X
[4X[25Xgap>[125X [27Xs1 := ConvertToMagmaInputString( M );[127X[104X
[4X[28X"F := GF(5);\nP := GL(2,F);\ngens := [\nP![2,0,0,1],\nP![4,1,4,0]\n];\nsub
We consider here the process for transferring utility functions from a package Home to Utils which has to avoid the potential problem of duplicate declarations of a function causing loading problems in GAP.
If the functions in Home all have names of the form HOME_FunctionName then, in Utils, these functions are likely to be renamed as FunctionName or something similar. In this case the problem of duplicate declarations does not arise. This is what has happened with transfers from the AutoDoc package.
The case where the function names are unchanged is more complicated. Initially we tried out a process which allowed repeated declarations and installations of the functions being transferred. This involved additions to the main library files global.g and oper.g. Since there were misgivings about interfering in this way with basic operations such as BIND_GLOBAL, a simpler (but slightly less convenient) process has been adopted.
Using this alternative procedure, the following steps will be followed when making transfers from Home to Utils.
(Home:) Offer functions for inclusion. This may be simply done by emailing a list of functions. More usefully, email the declaration, implementation, test and documentation files, e.g.: home.gd, home.gi, home.tst and home.xml. (All active authors should be involved.)
(Home:) Declare that m.n is the last version of Home to contain these functions, so that m.n+1 (or similar) will be the first version of Home to have all these functions removed, and to specify Utils as a required package.
(Utils:) Add strings "home" and "m.n" to the list UtilsPackageVersions in the file utils/lib/start.gd.
While the transfers are being made, it is essential that any new versions of Home should be tested with the latest version of Utils before they are released, so as to avoid loading failures.
(Utils:) Include the function declaration and implementation sections in suitable files, enclosed within a conditional clause of the form:
if OKtoReadFromUtils( "Home" ) then
. . . . . .
<the code>
. . . . . .
fi;
The function OKtoReadFromUtils returns true only if there is an installed version of Home and if this version is greater than m.n. So, at this stage, the copied code will not be read, and the transferred functions can only be called if Home has been installed.
(Utils:) Add the test and documentation material to the appropriate files. The copied code can be tested by temporarily moving Home away from GAP's package directory.
(Utils:) Release a new version of Utils containing all the transferred material.
(Home:) Edit out the declarations and implementations of all the transferred functions, and remove references to them in the manual and tests. Possibly add a note to the manual that these functions have been transferred. Add Utils to the list of Home's required packages in PackageInfo.g. Release a new version of Home.
(Utils:) In due course, when the new version(s) of Home are well established, it may be safe to remove the conditional clauses mentioned in item 4 above. The entry for Home in UtilsPackageLists may then be removed.
Finally, a note on the procedure for testing these functions. As long as a function being transferred still exists in the Home package, the code will not be read from Utils. So, when the tests are run, it is necessary to LoadPackage("home") before the function is called. The file utils/tst/testall.g makes sure that all the necessary packages are loaded before the individual tests are called.
The functions described here print lists or objects with an iterator with one item per line, either the whole list/iterator or certain subsets:
by giving a list of positions of items to be printed, or
by specifying a first item and then a regular step.
2.1-1 PrintSelection
‣ PrintSelection( obj, list )
( function )
‣ PrintSelection( obj, first, step[, last] )
( function )
This function, given three (or four) parameters, calls operations PrintSelectionFromList or PrintSelectionFromIterator which prints the first item specified, and then the item at every step. The fourth parameter is essential when the object being printed is infinite.
Alternatively, given two parameters, with the second parameter a list L of positive integers, only the items at positions in L are printed.
utils-0.93/doc/others.xml 0000644 0001751 0001751 00000012117 15105376105 015013 0 ustar runner runner
Various other functionsFile operations
This function has been transferred from package &RCWA;.
This function converts the &GAP; logfile filename to HTML.
It appears that the logfile should be in your current directory.
The extension of the input file must be *.log.
The name of the output file is the same as the one of the input file
except that the extension *.log is replaced by *.html.
There is a sample CSS file in utils/doc/gaplog.css,
which you can adjust to your taste.
LogTo( "triv.log" );
gap> a := 33^5;
39135393
gap> LogTo();
gap> Log2HTML( "triv.log" );
]]>
&LaTeX; strings
This function has been transferred from package &ResClasses;.
IntOrInfinityToLaTeX(n) returns the &LaTeX; string for n.
IntOrInfinityToLaTeX( 10^3 );
"1000"
gap> IntOrInfinityToLaTeX( infinity );
"\\infty"
]]>
This function has been transferred from package &RCWA;.
It returns the prime factorization of the integer n as a string in
&LaTeX; format.
LaTeXStringFactorsInt( Factorial(12) );
"2^{10} \\cdot 3^5 \\cdot 5^2 \\cdot 7 \\cdot 11"
]]>
Conversion to &Magma; strings
The function ConvertToMagmaInputString( obj [, str] )
attempts to output a string s which can be read into
&Magma;
so as to produce the same group in that computer algebra system.
In the second form the user specifies the name of the resulting object,
so that the output string has the form "str := ...".
When obj is a permutation group, the operation
PermGroupToMagmaFormat(obj) is called.
PermGroupToMagmaFormat
This function has been taken from other.gi in the main library
where it was called MagmaInputString.
When obj is a pc-group, the operation
PcGroupToMagmaFormat(obj) is called.
PcGroupToMagmaFormat
This function was private code of Max Horn.
When obj is a matrix group over a finite field,
the operation MatrixGroupToMagmaFormat(obj) is called.
MatrixGroupToMagmaFormat
This function is a modification of private code of Frank Lübeck.
Hopefully code for other types of group will be added in due course.
These functions should be considered experimental,
and more testing is desirable.
## permutation groups
gap> ConvertToMagmaInputString( Group( (1,2,3,4,5), (3,4,5) ) );
"PermutationGroup<5|(1,2,3,4,5),\n(3,4,5)>;\n"
gap> ConvertToMagmaInputString( Group( (1,2,3,4,5) ), "c5" );
"c5 := PermutationGroup<5|(1,2,3,4,5)>;\n"
gap> ## pc-group
gap> ConvertToMagmaInputString( DihedralGroup( IsPcGroup, 10 ) );
"PolycyclicGroup< f1,f2 |\nf1^2,\nf2^5,\nf2^f1 = f2^4\n>;\n"
gap> ## fp-group
gap> F2 := FreeGroup( 2 );;
gap> f := F2.1;; g := F2.2;;
gap> relq8 := [ f^4, g^4, f*g*f*g^-1, f^2*g^2 ];;
gap> q8 := F2/relq8;;
gap> ConvertToMagmaInputString( q8 );
no conversion function yet available for fp-groups
fail
gap> ## matrix group
gap> M := GL(2,5);; Size(M);
480
gap> s1 := ConvertToMagmaInputString( M );
"F := GF(5);\nP := GL(2,F);\ngens := [\nP![2,0,0,1],\nP![4,1,4,0]\n];\nsub
;\n"
gap> Print( s1 );
F := GF(5);
P := GL(2,F);
gens := [
P![2,0,0,1],
P![4,1,4,0]
];
sub
This method has been transferred from package ResClasses.
It provides a method for Comm when the argument is a list (enclosed in square brackets), and calls the function LeftNormedComm.
gap>Comm( [ (1,2), (2,3) ] );
(1,2,3)
gap>Comm( [(1,2),(2,3),(3,4),(4,5),(5,6)] );
(1,5,6)
gap>Comm(Comm(Comm(Comm((1,2),(2,3)),(3,4)),(4,5)),(5,6)); ## the same
(1,5,6)
5.1-2 IsCommuting
‣ IsCommuting( a, b )
( operation )
This function has been transferred from package ResClasses.
It tests whether two elements in a group commute.
gap>D12 := DihedralGroup( 12 );
<pc group of size 12 with 3 generators>
gap>SetName( D12, "D12" ); gap>a := D12.1;; b := D12.2;; gap>IsCommuting( a, b );
false
5.1-3 ListOfPowers
‣ ListOfPowers( g, exp )
( operation )
This function has been transferred from package RCWA.
The operation ListOfPowers(g,exp) returns the list \([g,g^2,...,g^{exp}]\) of powers of the element \(g\).
Since GAP uses right actions by default, the library contains the operation RightCoset(U,g) for constructing the right coset \(Ug\) of a subgroup \(U \leq G\) and an element \(g \in G\). It has been noted in the reference manual that, by inverting all the elements in \(Ug\), the left coset \(g^{-1}U\) is obtained.
Just for the sake of completeness, from August 2022 this package provides the operation LeftCoset(g,U) for constructing the left coset \(gU\). Users are strongly recommended to continue to use RightCoset for all serious calculations, since left cosets have a much simpler implementation and do not behave exactly like right cosets.
The methods for left cosets which are provided generally work by converting \(gU\) to \(Ug^{-1}\); applying the equivalent method for right cosets; and, if necessary, converting back again to left cosets.
\(G\) acts on left cosets by OnLeftInverse: \((gU)^{g_0} = g_0^{-1}*(gU) = (g_0^{-1}g)U\).
The inverse of the left coset \(gU\) is the right coset \(Ug^{-1}\), and conversely. This is an abuse of the attribute Inverse, since the standard requirement, that \(x*x^{-1}\) is an identity, does not hold.
This function has been transferred from package RCWA.
It constructs a group homomorphism which maps the generators of \(G\) to those of \(H\). Its intended use is when \(G\) is a free group, and a warning is printed when this is not the case. Note that anything may happen if the resulting map is not a homomorphism!
gap>G := Group( (1,2,3), (3,4,5), (5,6,7), (7,8,9) );;gap>phi := EpimorphismByGenerators( FreeGroup("a","b","c","d"), G );
[ a, b, c, d ] -> [ (1,2,3), (3,4,5), (5,6,7), (7,8,9) ]
gap>PreImagesRepresentativeNC( phi, (1,2,3,4,5,6,7,8,9) );
d*c*b*a
gap>a := G.1;; b := G.2;; c := G.3;; d := G.4;;gap>d*c*b*a;
(1,2,3,4,5,6,7,8,9)
gap>## note that it is easy to produce nonsense: gap>epi := EpimorphismByGenerators( Group((1,2,3)), Group((8,9)) );
Warning: calling GroupHomomorphismByImagesNC without checks
[ (1,2,3) ] -> [ (8,9) ]
gap>IsGroupHomomorphism( epi );
true
gap>Image( epi, (1,2,3) );
()
gap>Image( epi, (1,3,2) );
(8,9)
5.3-2 Pullback
‣ Pullback( hom1, hom2 )
( operation )
‣ PullbackInfo( G )
( attribute )
If \(\phi_1 : G_1 \to H\) and \(\phi_2 : G_2 \to H\) are two group homomorphisms with the same range, then their pullback is the subgroup of \(G_1 \times G_2\) consisting of those elements \((g_1,g_2)\) such that \(\phi_1 g_1 = \phi_2 g_2\).
The attribute PullbackInfo of a pullback group P is similar to DirectProductInfo for a direct product of groups. Its value is a record with the following components:
directProduct
the direct product \(G_1 \times G_2\), and
projections
a list with the two projections onto \(G_1\) and \(G_2\).
There are no embeddings in this record, but it is possible to use the embeddings into the direct product, see Embedding (Reference: Embedding).
Let G1 and G2 be two groups, Z1 be a central subgroup of G1, and Phi be an isomorphism from Z1 to a central subgroup of G2. The central product defined by these arguments is the factor group of the direct product of G1 and G2 by the central subgroup \(\{ (z, (\textit{Phi}(z))^{-1}) : z \in \textit{Z1} \}\).
The attribute CentralProductInfo of a group \(G\) that has been created by CentralProduct is similar to PullbackInfo (5.3-2) for pullback groups. Its value is a record with the following components.
projection
the epimorphism from the direct product of G1 and G2 to \(G\), and
phi
the map Phi.
Note that one can access the direct product as the Source (Reference: Source) value of the projection map, and one can access G1 and G2 as the two embeddings of this direct product, see Embedding (Reference: Embedding).
An endomorphism \(f : G \to G\) is idempotent if \(f^2=f\). It has an image \(R \leqslant G\); is the identity map when restricted to \(R\); and has a kernel \(N\) which has trivial intersection with \(R\) and has size \(|G|/|R|\).
The operation IdempotentEndomorphismsWithImage(genG,R) returns a list of the images of the generating set genG of a group \(G\) under the idempotent endomorphisms with image \(R\).
The attribute IdempotentEndomorphismsData(G) returns a record data with fields data.gens, a fixed generating set for \(G\), and data.images a list of the non-empty outputs of IdempotentEndomorphismsWithImage(genG,R) obtained by iterating over all subgroups of \(G\).
The operation IdempotentEndomorphisms(G) returns the list of these mappings obtained using IdempotentEndomorphismsData(G). The first of these is the zero map, the second is the identity.
The quaternion group q8 is an example of a group with a tail: there is only one subgroup in the lattice which covers the identity subgroup. The only idempotent isomorphisms of such groups are the identity mapping and the zero mapping because the only pairs \(N,R\) are the whole group and the identity subgroup.
gap>q8 := QuaternionGroup( 8 );;gap>IdempotentEndomorphisms( q8 );
[ [ x, y ] -> [ <identity> of ..., <identity> of ... ], [ x, y ] -> [ x, y ] ]
5.3-5 DirectProductOfFunctions
‣ DirectProductOfFunctions( G, H, f1, f2 )
( operation )
Given group homomorphisms \(f_1 : G_1 \to G_2\) and \(f_2 : H_1 \to H_2\), this operation return the product homomorphism \(f_1 \times f_2 : G_1 \times G_2 \to H_1 \times H_2\).
Let \(A_1,A_2\) be groups of automorphism of groups \(G_1,G_2\) respectively. The output of this function is a group \(A_1 \times A_2\) of automorphisms of \(G_1 \times G_2\).
utils-0.93/doc/_entities.xml 0000644 0001751 0001751 00000000530 15105376105 015466 0 ustar runner runner AutoDoc'>
{\sf MathJax}'>
ResClasses'>
RCWA'>
XMod'>
Home'>
{\sf Magma}'>
Utils'>
utils-0.93/doc/chap9.txt 0000644 0001751 0001751 00000014436 15105376105 014540 0 ustar runner runner
[1X9 [33X[0;0YWeb Downloads[133X[101X
[33X[0;0YThe [10XDownload[110X operation has been written by Thomas Breuer, incorporating a
number of suggestions from Max Horn, for version 0.77 of [5XUtils[105X. It
implements downloading a file from within [5XGAP[105X. It can use the [5XIO[105X or
[5XcurlInterface[105X packages, or [13Xwget[113X or [13Xcurl[113X, if installed, and it can be
extended with other download methods quite easily. It is envisaged that,
once other packages have started to use it, and any problems have been
addressed, that the functions will be transferred to the main [5XGAP[105X library.[133X
[1X9.1 [33X[0;0YFunctions for downloading files from the web[133X[101X
[1X9.1-1 Download[101X
[33X[1;0Y[29X[2XDownload[102X( [3Xurl[103X[, [3Xopt[103X] ) [32X function[133X
[33X[0;0YThis function downloads the file with the web address [3Xurl[103X, which must be a
string.[133X
[33X[0;0YThe result is a record which has at least the component [10Xsuccess[110X, with value
[9Xtrue[109X if the download was successful and [9Xfalse[109X otherwise. In the former case,
the component [10Xresult[110X is bound, whose value is a string that contains the
contents of the downloaded file. In the latter case, the component [10Xerror[110X is
bound, whose value is a string that describes the problem.[133X
[33X[0;0YThe function calls the methods stored in the global list [10XDownload_Methods[110X
until one of them is successful. Currently there are methods based on the
[5XGAP[105X functions [2XDownloadURL[102X ([14Xcurl: DownloadURL[114X) and [2XSingleHTTPRequest[102X ([14XIO:
SingleHTTPRequest[114X), and methods based on the external programs [10Xwget[110X and
[10Xcurl[110X.[133X
[33X[0;0YAn optional record [3Xopt[103X can be given. The following components are supported.[133X
[8X[10XmaxTime[110X[8X[108X
[33X[0;6YIf this component is bound then its value must be a nonnegative
integer [22Xn[122X, meaning that the function gives up after [22Xn[122X seconds.[133X
[33X[0;6YA zero value of [22Xn[122X means that no timeout is set, the method will never
give up in this case.[133X
[33X[0;6YThe default for [22Xn[122X is given by the value of the user preference
[10XDownloadMaxTime[110X (see [14X9.1-3[114X).[133X
[8X[10Xtarget[110X[8X[108X
[33X[0;6YIf this component is bound then its value must be a string that is a
local filename, and the function writes the downloaded contents to
this file; the returned record does not have a [10Xresult[110X component in
this case.[133X
[8X[10XverifyCert[110X[8X[108X
[33X[0;6YIf this component is bound and has the value [9Xfalse[109X then those download
methods that are based on [10Xcurl[110X or [10Xwget[110X will omit the check of the
server's certificate.[133X
[33X[0;6YThe same effect is achieved for all [2XDownload[102X calls by setting the user
preference [10XDownloadVerifyCertificate[110X (see [14X9.1-2[114X) to [9Xfalse[109X and omitting
the [10XverifyCert[110X component from [3Xopt[103X.[133X
[4X[32X Example [32X[104X
[4X[28X[128X[104X
[4X[25Xgap>[125X [27Xurl:= "https://www.gap-system.org/index.html";;[127X[104X
[4X[25Xgap>[125X [27Xres1:= Download( url );;[127X[104X
[4X[25Xgap>[125X [27Xres1.success;[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27XIsBound( res1.result ) and IsString( res1.result );[127X[104X
[4X[28Xtrue[128X[104X
[4X[25Xgap>[125X [27Xres2:= Download( Concatenation( url, "xxx" ) );;[127X[104X
[4X[25Xgap>[125X [27Xres2.success;[127X[104X
[4X[28Xfalse[128X[104X
[4X[25Xgap>[125X [27XIsBound( res2.error ) and IsString( res2.error );[127X[104X
[4X[28Xtrue[128X[104X
[4X[28X[128X[104X
[4X[32X[104X
[1X9.1-2 [33X[0;0YUser preference [10XDownloadVerifyCertificate[110X[101X[1X[133X[101X
[33X[0;0YThe value [9Xtrue[109X (the default) means that the server's certificate is checked
in calls of [2XDownload[102X ([14X9.1-1[114X), such that nothing gets downloaded if the
certificate is invalid.[133X
[33X[0;0YIf the value is [9Xfalse[109X then download methods are supposed to omit the check
of the server's certificate (this may not be supported by all download
methods).[133X
[33X[0;0YOne can set the value of the preference to be [10Xval[110X via [2XSetUserPreference[102X
([14XReference: SetUserPreference[114X), by calling [10XSetUserPreference( "utils",
"DownloadVerifyCertificate", val )[110X, and access the current value via
[2XUserPreference[102X ([14XReference: UserPreference[114X), by calling [10XUserPreference(
"utils", "DownloadVerifyCertificate" )[110X.[133X
[33X[0;0YWe recommend leaving this preference at its default value [9Xtrue[109X. Sometimes it
can be necessary to change it, e.g. to work around issues with old operating
systems which may not be able to correctly verify new certificates. In
general it is better to update such a system, but if that is not an option,
then disabling certificate checks may be a good last resort.[133X
[1X9.1-3 [33X[0;0YUser preference [10XDownloadMaxTime[110X[101X[1X[133X[101X
[33X[0;0YThe value [10X0[110X (the default) means that no timeout is set in calls of [2XDownload[102X
([14X9.1-1[114X). If the value is a positive integer [22Xn[122X then those download methods
that support a timeout will give up after [22Xn[122X seconds.[133X
[33X[0;0YOne can set the value of the preference to be [10Xval[110X via [2XSetUserPreference[102X
([14XReference: SetUserPreference[114X), by calling [10XSetUserPreference( "utils",
"DownloadMaxTime", val )[110X, and access the current value via [2XUserPreference[102X
([14XReference: UserPreference[114X), by calling [10XUserPreference( "utils",
"DownloadMaxTime" )[110X.[133X
utils-0.93/doc/toggless.css 0000644 0001751 0001751 00000001672 15105376105 015332 0 ustar runner runner /* toggless.css Frank LĂĽbeck */
/* Using javascript we change all div.ContSect to div.ContSectOpen or
div.ContSectClosed. This way the config for div.ContSect in manual.css
is no longer relevant. Here we add the CSS for the new elements. */
/* This layout is based on an idea by Burkhard Höfling. */
div.ContSectClosed {
text-align: left;
margin-left: 1em;
}
div.ContSectOpen {
text-align: left;
margin-left: 1em;
}
div.ContSectOpen div.ContSSBlock {
display: block;
text-align: left;
margin-left: 1em;
}
div.ContSectOpen div.ContSSBlock a {
display: block;
width: 100%;
margin-left: 1em;
}
span.tocline a:hover {
display: inline;
background: #eeeeee;
}
span.ContSS a:hover {
display: inline;
background: #eeeeee;
}
span.toctoggle {
font-size: 80%;
display: inline-block;
width: 1.2em;
}
span.toctoggle:hover {
background-color: #aaaaaa;
}
utils-0.93/doc/chap4_mj.html 0000644 0001751 0001751 00000030633 15105376105 015343 0 ustar runner runner
GAP (Utils) - Chapter 4: Number-theoretic functions
This function has been transferred from package RCWA.
The function AllSmoothIntegers(maxp,maxn) returns the list of all positive integers less than or equal to maxn whose prime factors are all in the list \(L = \{p ~|~ p \leqslant maxp, p~\mbox{prime} \}\).
In the alternative form, when \(L\) is a list of primes, the function returns the list of all positive integers whose prime factors lie in \(L\).
This function has been transferred from package RCWA.
The command AllProducts(L,k) returns the list of all products of k entries of the list L. Note that every ordering of the entries is used so that, in the commuting case, there are bound to be repetitions.
This function has been transferred from package RCWA.
For a positive integer n and a set of positive integers S, this function returns the list of partitions of n into distinct elements of S. Unlike RestrictedPartitions, no repetitions are allowed.
This function has been transferred from package RCWA.
The function NextProbablyPrimeInt(n) does the same as NextPrimeInt(n) except that for reasons of performance it tests numbers only for IsProbablyPrimeInt(n) instead of IsPrimeInt(n). For large n, this function is much faster than NextPrimeInt(n)
gap>n := 2^251;
3618502788666131106986593281521497120414687020801267626233049500247285301248
gap>NextProbablyPrimeInt( n );
3618502788666131106986593281521497120414687020801267626233049500247285301313
gap>time;
1
gap>NextPrimeInt( n );
3618502788666131106986593281521497120414687020801267626233049500247285301313
gap>time;
213
4.1-5 PrimeNumbersIterator
‣ PrimeNumbersIterator( [chunksize] )
( function )
This function has been transferred from package RCWA.
This function returns an iterator which runs over the prime numbers n ascending order; it takes an optional argument chunksize which specifies the length of the interval which is sieved in one go (the default is \(10^7\)), and which can be used to balance runtime vs. memory consumption. It is assumed that chunksize is larger than any gap between two consecutive primes within the range one intends to run the iterator over.
gap>iter := PrimeNumbersIterator();;gap>for i in [1..100] do p := NextIterator(iter); od;gap>p;
541
gap>sum := 0;;gap>## "prime number race" 1 vs. 3 mod 4gap>for p in PrimeNumbersIterator() do > if p <> 2 then sum := sum + E(4)^(p-1); fi;> if sum > 0 then break; fi;> od;gap>p;
26861