########################################################################### ## ## gpl.g Group Presentations Library version 1.0 ## ## Copyright (C) 1997, Roderik Lindenbergh, ## Queen Mary and Westfield College, London. ## email: R.C.Lindenbergh@qmw.ac.uk ## ## The work done to create this package was enabled by an ## European Union HCM grant in "Computational Group Theory". ## ## This file contains: ## 1. Presentations for a number of simple sporadic groups ## and non-simple sporadic groups. ## 2. Words that generate subgroups in these presentations. ## 3. A number of GAP procedures that enable GAP users: ## * to access the information mentioned in 1. and 2. ## * to create finitely presented groups via strings. ## * to create string presentations from finitely ## presented groups. ## ## AVAILABILITY ## ## This file and the documentation file that belongs to it are ## available free of charge from ## ## 1. ftp math.rwth-aachen.de/pub/incoming ## 2. http://www.maths.qmw.ac.uk/~rcl/GPL/GPL.html ## ## under the names ## ## gpl.g - this file ## gpl.ps.gz - the compressed postscript file containing ## documentation ## ## GLOBAL VARIABLES ## GPL_PCE := true; ## ## if "_PCE" (Purpose of Coset Enumeration) in a list of strings ## representing relations occurs, these relations will only be added ## to the presentation if the global variable GPL_PCE is "true". ## ## PACKAGES USED ## RequirePackage( "grape" ); ## ## LIST OF PROCEDURES ## ## DiffTwoTuples := function( list ) ## TwoTupleDifference := function( list, edges ) ## AddTrivialRelations := function( genlist, rellist ) ## AddNonEdgeRelations := function( genlist, edges, rellist ) ## DeCox := function( string ) ## MakeStringList := function( string ) ## DeCoxList := function( string ) ## ToGapWord := function( string ) ## FindOperators := function( string ) ## LHS := function( string ) ## CorrespondingBracket := function( string ) ## RHS := function( string ) ## ConCat := function( list ) ## RemoveBlanks := function( string ) ## RemoveRedundantBrackets := function( string ) ## MakeWordList := function( string ) ## ListDepth := function( object ) ## DecodeRel := function( group, relation ) ## IsCoxeterGraph := function( str ) ## GetGenerators := function( string, used ) ## GeneratorMap := function( string, map ) ## IsGeneratorString := function( string ) ## FpGroupViaStrings := function( arg ) ## SubgroupViaStrings := function(arg) ## GPLTableOps.Print := function ( r ) ## GroupRecordGPL := function( grname ) ## GpOps.Print := function( r ) ## GroupPresentationGPL := function( grname, number ) ## InitializeGroupPresentationGPL := function( gp ) ## GroupPresentationsGPL := function( grname ) ## AvailableGroupPresentationsGPL := function() ## SubgroupGPL := function( arg ) ## AvailableSubgroupsGPL := function( pres ) ## AvailableMaximalSubgroupsGPL := function( pres ) ## StringDigit := function( number ) ## FindPowersInWord := function( wordstring ) ## FpWordToString := function( word, generators, ext ) ## StringPresentation := function( group ) ## NrGeneratorsInWord := function( word, gen ) ## ReversedWord := function( word ) ## ListToString := function( list ) ## JoinCoxPaths := function( arg ) ## CoxString := function( gen, coxrel ) ## CoxeterStringPresentation := function( group ) ## ## CONVENTIONS ## ## * Sporadic groups have the same names as the corresponding ## character tables in GAP. ## * Subgroups of sporadic groups are named using the naming ## conventions for Character Tables in GAP as much as ## possible. Other often used names for a specific group ## are sometimes added in the list that corresponds with ## this subgroup. ## * Subgroups that are maximal are marked via a string ## "_MT", Maximal True, in the list that corresponds with ## every subgroup. Non-maximals are marked "_MF". ## * Every list that corresponds with a subgroup contains ## a string "_A**" that indicates the source of the words ## (A stands for Author) generating this subgroup in the ## given presentation. ## "_APS" indicates that the words are given in the book ## "Low Rank Representations and Graphs for ## Sporadic Groups" -- C.E Praeger, L.H. Soicher, ## Cambridge University Press, 1997. ## References to the original authors are given ## in the book. ## "_AMS" indicates that the words were found by ## Martin Schoenert. ## "_ARL" indicates that the words were found by ## Roderik Lindenbergh. ## ## ## LIBRARY OF PRESENTATIONS ## GPLTable := rec(); ########################################################################### GPLTable.("M11") := rec( info := ["M11", 7920], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.M11.1 := rec( presdef := [ "a3b5c3d3e4c", , "a=(ce)^2", "(abc)^5,(bcd)^5" ], subgroups := [ ["A6.2_3" , "b,c,d,abcbae" ,"_APS" ,"_MT" ,"M10" ], ["L2(11)" , "a,b,c,d" ,"_APS" ,"_MT" ], ["A6" , "b,c,d,d^(abcbae)" ,"_APS" ,"_MF" ], ["3^2:Q8.2" , "a,b,d,e,(decbcdcba)^(cbc)" ,"_APS" ,"_MT" ,"M9:2" ], ["A5.2" , "a,b,c,e" ,"_APS" ,"_MT" ,"S5" ], ["3^2:8" , "ab,de,(decbcdcba)^(cbc)" ,"_APS" ,"_MF" ], ["2.S4" , "a,c,d,e" ,"_ARL" ,"_MT" ] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("M12") := rec( info := ["M12", 95040], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.M12.1 := rec( presdef := [ "b4f3a3b5c3d3e4c,e6f", , "a=(ce)^2,d=(bf)^2,(adef)^3,(bcef)^6", ], subgroups := [ ["M11" , "a,b,c,d,e" ,"_APS" ,"_MT" ], ["A6.2^2" , "b,c,d,f,abcbae" ,"_APS" ,"_MT" ,"M10:2" ], ["PGL2(9)" , "b,c,d,fabcbae" ,"_APS" ,"_MF" ], ["S6" , "b,c,d,f,d^(abcbae)" ,"_APS" ,"_MF" ], ["L2(11)" , "abc,bcd,aefd" ,"_APS" ,"_MT" ], ["L2(11)" , "a,b,c,d" ,"_APS" ,"_MF" ], ["3^2.2.S4" , "a,b,d,e,f" ,"_APS" ,"_MT" ,"M9:S3" ], ["2xS5" , "bcef,b^c,(ce)^(dcbca)" ,"_ARL" ,"_MT" ], ["M8.S4" , "c,d,(f(bcef)^3)^5" ,"_ARL" ,"_MT" ], ["4^2:D12" , "d,(ef)^2ec,((bcef)^2)^(abfa)" ,"_ARL" ,"_MT" ], ["A4xS3" , "cfebd,b^(facbca),(ab)^(fcbafadced)" ,"_ARL" ,"_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("M12:2") := rec( info := ["M12:2",2*95040], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("M12:2").1 := rec( presdef := [ "b4f3a3b5c3d3e4c,e6f", "t", "a=(ce)^2,d=(bf)^2,(adef)^3,(bcef)^6,t^2,a^td,b^tc,e^tf", ], subgroups := [ ["L2(11):2" , "a,b,c,d,t" ,"_APS","_MT"], ["L2(11):2" , "abc,bcd,aefd,t" ,"_APS","_MT"], ["(2^2xA5):2" , "bcef,b^c,(ce)^(dcbca),bct" ,"_ARL","_MT"], ["3_{+}^{1+2}:D8", "b,e,t^(cbadef)" ,"_ARL","_MT"], ["(M8.S4).2" , "c,d,(fbct)^3" ,"_ARL","_MT"], ["(4^2:D12).2" , "(ef)^2ec,((bcef)^2)^(abfa),t^(cete)" , "_ARL","_MT"], ["S4xS3" , "((bc)^2d)^(ae),((bcef)^3)^(bacba),t^f" , "_ARL","_MT"], ["S5" , "bcbcbad,becbfct" ,"_ARL","_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("J1") := rec( info := ["J1", 175560], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.J1.1 := rec( presdef := [ "a3b5c3d5e", , "(abc)^5,a=(cde)^5", "(bcd)^5" ], subgroups := [ ["L2(11)" , "a,b,c,d" , "_APS" ,"_MT"], ["2^3.7.3" , "a,c,e,bacbcbdceded,bacbcb" , "_AMS" ,"_MT"], ["2xA5" , "c,d,e" , "_AMS" ,"_MT"], ["19:6" , "abcde,badcbcbedceded" , "_AMS" ,"_MT"], ["11:10" , "abcbdc,bcdcacedcbacedcbacedce" , "_AMS" ,"_MT"], ["D6xD10" , "a,b,d,e" , "_AMS" ,"_MT"], ["7:6" , "bacbcbdceded,badedcbcd" , "_AMS" ,"_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("M22") := rec( info := ["M22", 443520], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.M22.1 := rec( presdef := [ "a3b5c3d,a4e3c", , "(abc)^5,(eab)^3,(bce)^5,(aecd)^4,(abce)^8", "(bcd)^5" ], subgroups := [ ["L3(4)" , "a,b,c,a^(bcde)" ,"_APS" ,"_MT","M21"], ["2^4:a6" , "a,b,c,e" ,"_APS" ,"_MT" ], ["A7" , "b,c,d,d^(cbae)" ,"_APS" ,"_MT" ], ["2^4:s5" , "a,c,d,e,bcdecb" ,"_APS" ,"_MT" ], ["2^4:L2(5)" , "b,c,e,(aec)^3" ,"_APS" ,"_MF" ], ["2^3:sl(3,2)" , "a,c,d,e,a^(ecb)" ,"_APS" ,"_MT" ], ["A6.2_3" , "b,c,e,abcdcbeacbcdcbaecbacd" ,"_APS" ,"_MT","M10"], ["L2(11)" , "a,b,c,d" ,"_APS" ,"_MT" ] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("M22:2") := rec( info := ["M22:2", 2*443520], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("M22:2").1 := rec( presdef := [ "a3b5c3d,a4e3c", "t" , "(abc)^5,(eab)^3,(bce)^5,(aecd)^4,(abce)^8,\ t^2,(at)^2,(ct)^2,(dt)^2,(et)^2,b^tbe", "(bcd)^5" ], subgroups := [ ["L3(4):2_2" , "a,b,c,a^(bcde),eabt" ,"_APS" ,"_MT" ], ["2^4:s6" , "a,b,c,e,t" ,"_APS" ,"_MT" ], ["2^5:s5" , "a,c,d,e,bcdecb,t" ,"_APS" ,"_MT" ], ["2^5:L2(5)" , "b,c,e,(aec)^3,t" ,"_APS" ,"_MF" ], ["2^3:sl(3,2)x2" , "a,c,d,e,a^(ecb),t" ,"_APS" ,"_MT" ], ["A6.2^2" , "b,c,e,abcdcbeacbcdcbaecbacd,t" ,"_APS" ,"_MT" ], ["L2(11):2" , "a,b,c,d,(adectbcdeabc)^(bce)" ,"_ARL" ,"_MT" ] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("J2") := rec( info := ["J2", 604800], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.J2.1 := rec( presdef := [ "a5b3c8d3e", , "a=(cd)^4,((bcdcd)^5e)^3", "(abc)^5" ], subgroups := [ ["U3(3)" , "abdc,a^(bcde)" ,"_ARL","_MT"], ["3.A6.2_2" , "a,b,c,d" ,"_APS","_MT" ,"3.PGL2(9)"], ["2^1+4b:a5" , "c,d,e,(bcdcd)^5" ,"_ARL","_MT"], ["2^2+4.3xs3" , "e,cdcd,(cb)^(ab)" ,"_ARL","_MT"], ["a4xa5" , "a,b,c,e,(bcdcd)^5" ,"_ARL","_MT"], ["a5xd10" , "a,b,d,e,(bcdcd)^5" ,"_ARL","_MT"], ["L3(2).2" , "abcdecbdc,e^(dcbadce)" ,"_ARL","_MT"], ["5^2:d12" , "b,e,c(babdcbd)^(cdedcd)" ,"_ARL","_MT"], ["A5" , "de(bcdcd)^5,(bc)^(dcbcdacebdec)" ,"_ARL","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("J2:2") := rec( info := ["J2:2", 2*604800], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("J2:2").1 := rec( presdef := [ "a3b3c8d3e3f", , "a=(cd)^4,(bcde)^8", ], subgroups := [ ["U_3(3):2" , "a,b,c,d,e" ,"_APS","_MT"], ["3.A6.2^2" , "a,b,d,e,cdcedc,cbadcbadcbedcbdc,fedcdef" ,"_AMS","_MT"], ["2^1+4b.S5" , "a,c,d,e,f,e^(dcbadcb)" ,"_APS","_MT"], ["2^2+4:3xS3.2" , "cd,c,bacbdcdedcbadcb,baedcbde,efe" ,"_AMS","_MT"], ["(A4xA5):2" , "a,b,d,e,f,cdcedcfedc" ,"_AMS","_MT"], ["(A5xD10).2" , "bedfe,dedcdefedcd" ,"_ARL","_MT"], ["L3(2):2x2" , "a,b,c,d,f" ,"_AMS","_MT"], ["5^2:(4xS3)" , "dedcdefedcd,eabadcbade" ,"_ARL","_MT"], ["S5" , "bc,(df)^(cdbfaefcd),f" ,"_ARL","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("M23") := rec( info := ["M23", 10200960], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.M23.1 := rec( presdef := [ "a3b5c3d3f6e,a4e3c4f", , "a=(cf)^2,b=(ef)^3,(eab)^3,(bce)^5,(aecd)^4,(bcef)^4", "(bcd)^5" ], subgroups := [ ["M22" , "a,b,c,d,e" ,"_APS","_MT"], ["L3(4).2_2" , "a,b,c,f,a^(bcde)" ,"_APS","_MT"], ["2^4:a7" , "a,b,c,e,f" ,"_APS","_MT"], ["A8" , "a,b,d,e,f,e^(fdc)" ,"_APS","_MT"], ["M11" , "a,b,c,d,f" ,"_APS","_MT"], ["2^4:(3xa5):2" , "c^a,(c(e^(cd)))^b,(bd)^(cbcbf)" ,"_ARL","_MT"], ["23:11" , "cdfe,(bcdf)^(ce((cef)^2e)^(fc))" ,"_ARL","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("HS") := rec( info := ["HS", 44352000], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.HS.1 := rec( presdef := [ "b4f3a3b5c3d,a4e3c", , "d=(bf)^2,d=(eaf)^3,(eab)^3,(bce)^5", "(abc)^5" ], subgroups := [ ["M22" , "a,b,c,d,e" ,"_APS","_MT"], ["U3(5).2" , "b,c,d,f,d^(cbae),abfae" ,"_APS","_MT"], ["U3(5)" , "b,c,d,f,d^(cbae)" ,"_APS","_MF"], ["L3(4).2_1" , "a,b,c,a^(bcde),eafabceafbcbeaf" ,"_APS","_MT"], ["A8.2" , "a,c,d,e,f,a^(ecb),(acbf(aecb)^2faec)^(bcb)" ,"_ARL","_MT"], ["2^4.s6" , "c^a,(c(e^(cd)))^b,f^a,f^b" ,"_ARL","_MT"], ["4^3:psl(3,2)" , "c,d,a^(ecb),a^(bcdecbf)" ,"_ARL","_MT"], ["M11" , "a,b,f,c" ,"_ARL","_MT"], ["4.2^4:s5" , "bcadbefdac,ceacec,bcdcecdfb" ,"_ARL","_MT"], ["2xa6.2^2" , "(aeaebdfac)^5,e,(fb)^a" ,"_ARL","_MT"], ["5:4xa5" , "abcdef,(aebdfae)^(cbacf),(aeaebdf)^(cfabeacd),\ ((abcdfae)^3)^(becfabec)" ,"_ARL","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("HS:2") := rec( info := ["HS:2" , 2*44352000], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("HS:2").1 := rec( presdef := [ "b4f3a3b5c3d,a4e3c", "t" , "d=(bf)^2,d=(eaf)^3,(eab)^3,(bce)^5,t^2,(at)^2,(ct)^2,\ (dt)^2,(et)^2,(ft)^2,b^tbe", "(abc)^5" ], subgroups := [ ["M22:2" , "a,b,c,d,e,t" ,"_APS","_MT"], ["L3(4).2_2" , "a,b,c,a^(bcde),eafabceafbcbeaf,eabt", "_ARL","_MT"], ["A8.2x2" , "a,c,d,e,f,t,a^(ecb),t^((abcft)^8)" ,"_APS","_MT"], ["2^5.s6" , "c^a,(c(e^(cd)))^b,f^a,f^b,t" ,"_ARL","_MT"], ["4^3:(psl(3,2)x2)" , "c,d,a^(ecb),a^(bcdecbf),t" ,"_ARL","_MT"], ["2_+^(1+6):s5" , "a,b,(d(acbdcef)^5)^3,t" ,"_ARL","_MT"], ["(2xa6.2^2).2" , "(aeaebdfac)^5,e,(fb)^a,ft" ,"_ARL","_MT"], ["5_+^{1+2}:[2^5]" , "bcdctbcbdc,bacbfeacbcdt" ,"_ARL","_MT"], ["5:4xs5" , "abcdef,(aebdfae)^(cbacf),\ ((abcdfae)^3)^(becfabec),(eft)^(ecbctdtfababcb)" ,"_ARL","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("J3") := rec( info := ["J3", 50232960], presentations := 0 ); ########################################################################### GPLTable.("M24") := rec( info := ["M24", 244823040], presentations := 2 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.M24.1 := rec( presdef := [ "a3b5c3d3f6e,a4e3c4f4g4b", , "a=(cf)^2,e=(bg)^2,b=(ef)^3,(aecd)^4,(baefg)^3,(bcef)^4", "(bcd)^5" ], subgroups := [ ["M23" , "a,b,c,d,e,f" ,"_APS","_MT"], ["M22:2" , "a,b,c,d,e,g" ,"_APS","_MT"], ["2^4:A8" , "a,b,c,e,f,g" ,"_APS","_MT"], ["L3(4):S3" , "a,b,c,a^(bcde),f,eabg" ,"_APS","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.M24.2 := rec( presdef := [ "a3b3c10d3e,b4f,d3g", , "a=(cd)^5,a=(cde)^5,f=(cdg)^5,e=(bcf)^3,(abf)^3", ], subgroups := [ ["M12:2" , "a,b,c,d,e,f" ,"_APS", "_MT"], ["2^6:3:S6" , "a,c,d,e,f,g,bcdegdcb" ,"_APS", "_MT"], ["M12" , "ab,bc,d,e,f" ,"_APS", "_MF"], ["2^6:3:A6" , "a,c,d,e,f,g,d^(bcdegdcb)" ,"_APS", "_MF"], ["2^6:(L3(2)xS3)", "a,b,d,e,f,g,(edg)^(dcbdcdc)" ,"_APS", "_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("McL") := rec( info := ["McL", 244823040], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.McL.1 := rec( presdef := [ "a3b5c3d3f6e,a4e3c4f", , "a=(cf)^2,b=(ef)^3,(eab)^3,(bce)^5,(aecd)^4,(cef)^7", "(bcd)^5" ], subgroups := [ ["U4(3)" , "cef,dfcd" ,"_APS","_MT"], ["M22" , "a,b,c,d,e" ,"_APS","_MT"], ["U3(5)" , "b,(de)^(cbac),acdcbeace,(cdfbeaecd)^3" ,"_APS","_MT"], ["3^{1+4}_+:2.S5", "cdfbeaecd,cbadecbcbadcecbaecd" ,"_APS","_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("He") := rec( info := ["He", 4030387200], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.He.1 := rec( presdef := [ "a4b3c10d3e,d3f4g3d", , "e=(fg)^2,e=(abc)^3,a=(cd)^5,(cdfg)^4", ], subgroups := [ ["S4(4):2" , "a,c,d,e,f,(ab)^2,(bcde)^7" ,"_APS" ,"_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("He:2") := rec( info := ["He", 2*4030387200], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("He:2").1 := rec( presdef := [ "a4b3c10d3e,d3f4g3d", "h" , "e=(fg)^2,e=(abc)^3,a=(cd)^5,(cdfg)^4,\ h^2,(ah)^2,(bh)^2,(ch)^2,(dh)^2,(eh)^2,f^hg", ], subgroups := [ ["S4(4):4" , "a,c,d,e,f,(ab)^2,(bcde)^7,bcdcdgfdcbdfh","_APS","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Ru") := rec( info := ["Ru", 145926144000], presentations := 0 ); ########################################################################### GPLTable.("Suz") := rec( info := ["Suz", 448345497600], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Suz.1 := rec( presdef := [ "a5b3c8d3e,b3f4g3b", , "a=(cd)^4,a=(fg)^2,(abcf)^5,(bfg)^5,((bcdcd)^5e)^3", "(abcg)^5" ], subgroups := [ ["G2(4)" , "a,b,c,d,e,f" ,"_APS", "_MT"], ["3_2.U4(3):2_3" , "a,b,c,d,f,g" ,"_APS", "_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Suz:2") := rec( info := ["Suz:2", 448345497600], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("Suz:2").1 := rec( presdef := [ "a5b3c8d3e,b3f4g3b", "t" , "a=(cd)^4,a=(fg)^2,(abcf)^5,(bfg)^5,((bcdcd)^5e)^3,\ t^2,(at)^2,(bt)^2,(ct)^2,(dt)^2,(et)^2,f^tg", "(abcg)^5" ], subgroups := [ ["3.U4(3).(2^2)" , "a,b,c,d,f,g,t" ,"_APS" ,"_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("ON") := rec( info := ["ON", 460815505920], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.ON.1 := rec( presdef := [ "a3b3c8d3e3f", "g", "g^4,af=g^2,af=(cd)^4,cc^(dgdg),dd^(cgcg),(bcdg)^5,\ gbg^cg^bg^c,geg^dg^eg^d", ], subgroups := [ ["L3(7):2" , "a,b,c,d,e,f" ,"_APS","_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Co3") := rec( info := ["Co3", 495766656000], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Co3.1 := rec( presdef := [ "b4g3a3b5c3d3f4c3e4a,e6f6g", , "a=(cf)^2,b=(ef)^3,d=(bg)^2,d=(eag)^3,(eab)^3,\ (bce)^5,(adfg)^3,(cef)^7", ], subgroups := [ ["McL:2" , "a,b,c,d,e,f,gfdcecbagfecdfegfg" ,"_APS", "_MT"], ["McL" , "a,b,c,d,e,f" ,"_APS", "_MF"], ["HS" , "a,b,c,d,e,g" ,"_APS", "_MT"], ["M23" , "a,b,c,d,e,(feadfegfgefd)^(cef)" ,"_APS", "_MT"], ["2.S6(2)" , "b,d,e,f,c^(ba),cbdb^cg,e^ab^cbec,(deacbacde)^(bca)" ,"_APS","_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Co2") := rec( info := ["Co2", 42305421312000], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Co2.1 := rec( presdef := [ "a3b5c3d3f6e,a4e3c4f4g4b", , "a=(cf)^2,e=(bg)^2,b=(ef)^3,(aecd)^4,(baefg)^3,(cef)^7",, ], subgroups := [ ["U6(2):2" , "g,cef,dcfd,deaefecdfgfdecdfgbfcde","_APS", "_MT"], ["U6(2)" , "g,cef,dcfd" ,"_APS", "_MF"], ["2^{10}:M22:2" , "a,b,c,d,e,g,(gfdc)^4" ,"_APS", "_MT"], ["McL" , "a,b,c,d,e,f" ,"_APS", "_MT"], ["2^{1+8}:S6(2)", "a,b,d,e,f,g,(gfdc)^4,(abcdefg)^5" ,"_APS", "_MT"], ["HS:2" , "a,b,c,d,f,(adecgbcdeabc)^(bce)" ,"_APS", "_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Fi22") := rec( info := ["Fi22", 64561751654400], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Fi22.1 := rec( presdef := [ "a3b3c3d3e3f3g,d3h3i", , "(dcbdefdhi)^(10),(abcdefh)^9,(bcdefgh)^9",, ], subgroups := [ ["2.U6(2)" , "a,c,d,e,f,g,h,i,(abcdeh)^5" ,"_APS", "_MT"], ["O7(3)" , "b,c,d,e,f,g,h,i" ,"_APS", "_MT"], ["2^{10}:M22" , "a,c,e,g,h,bacb,dced,fegf,dchd,dehd,(cdehi)^4" ,"_APS", "_MT"], ["2^6:S6(2)" , "a,b,c,d,e,f,g,h" ,"_APS", "_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Fi22:2") := rec( info := ["Fi22", 64561751654400], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("Fi22:2").1 := rec( presdef := [ "a3b3c3d3e3f3g,d3h3i", "j" , "(dcbdefdhi)^(10),(abcdefh)^9,(bcdefgh)^9,\ j^2,a^jg,b^jf,c^je,(dj)^2,(hj)^2,(ij)^2",, ], subgroups := [ ["O8^+(2):S3x2" , "d,h,i,ag,bf,ce,j", "_APS", "_MT"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("HN") := rec( info := ["HN", 273030912000000], presentations := 0 ); ########################################################################### GPLTable.("Ly") := rec( info := ["Ly", 51765179004000000], presentations := 0 ); ########################################################################### GPLTable.("Th") := rec( info := ["Th", 90745943887872000], presentations := 0 ); ########################################################################### GPLTable.("Fi23") := rec( info := ["Fi23", 4089470473293004800], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Fi23.1 := rec( presdef := [ "a3b3c3d3e3f3g3j,d3h3i", , "(dcbdefdhi)^(10),(abcdefh)^9",, ], subgroups := [ ["2.Fi22" , "a,b,c,d,e,f,g,h,i" ,"_APS","_MT"], ["O8^+(3):S3" , "a,b,c,d,e,f,g,i,j,(abcdeh)^5,a^((bcdefghi)^5)" ,"_APS","_MT"], ["O8^+(3):3" , "ab,ac,ad,ae,af,ag,ai,aj,a(abcdeh)^5,aa^((bcdefghi)^5)", "_APS","_MF"], ["O8^+(3):2" , "b,c,d,e,f,g,h,i,j" ,"_APS","_MF"], ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("Co1") := rec( info := ["Co1", 4157776806543360000], presentations := 2 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Co1.1 := rec( presdef := [ "b4h3a3b5c3d3f4c3e4a,b4g4f,e6f6h", , "a=(cf)^2,e=(bg)^2,b=(ef)^3,d=(bh)^2,d=(eah)^3,\ (adfh)^3,(baefg)^3,(cef)^7,(adefcefgh)^(39)",, ], subgroups := [ ["Co2" , "a,b,c,d,e,f,g,(adefcefgh)^(39)" , "_APS", "_MT"], ["2^{11}:M24" , "a,b,d,e,f,g,h,(gfdc)^4,(adefcefgh)^(39)", "_APS", "_MT"], ["Co3" , "a,b,c,d,e,f,h,(adefcefgh)^(39)" , "_APS", "_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.Co1.2 := rec( presdef := [ "a3b3c8d3e3f3g3h3i", , "a=(cd)^4,(bcde)^8,((bcdcdefgh)^(13)i)^3", ], subgroups := [ ["2x3.Suz:2" , "a,b,c,d,e,f,g,h,((bcdcdefgh)^(13)i)^3","_APS","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("J4") := rec( info := ["J4", 86775571046077562880], presentations := 0 ); ########################################################################### GPLTable.("F3+") := rec( info := ["F3+", 1255205709190661721292800], presentations := 0 ); ########################################################################### GPLTable.("F3+:2") := rec( info := ["F3+", 1255205709190661721292800], presentations := 1 ); # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # GPLTable.("F3+:2").1 := rec( presdef := [ "l3k3a3b3c3d3e3f3g3j,d3h3i", , "l=(abcdefh)^9,(dcbakldefgjdhi)^(17)", ], subgroups := [ ["Fi23x2" , "a,b,c,d,e,f,g,h,i,j,l","_APS","_MT"] ], text := "origin: Low Rank Representations and Graphs for Sporadic Groups" ); ########################################################################### GPLTable.("B") := rec( info := ["B", 4154781481226426191177580544000000], presentations := 0 ); ########################################################################### GPLTable.("M") := rec( info := ["M", 26, 808017424794512875886459904961710757005754368000000000 ], presentations := 0 ); ########################################################################### ## ## PROCEDURES ## ########################################################################### ## DiffTwoTuples( generates a list of pairs of ## different elements of . ## DiffTwoTuples := function( list ) local tt, i, j, k, l; list := Set(list); l := Length(list); j := 1; tt := []; for i in [j..(l-1)] do for k in [(j+1)..l] do Add(tt, [ list[i], list[k]] ); od; j := j+1; od; return( tt ); end; ########################################################################### ## TwoTupleDifference( , ) returns the ## complement of in . ## TwoTupleDifference := function( list, edges ) local tt, e, t; tt := DiffTwoTuples( list ); for e in edges do tt := Filtered( tt, t -> not ( ( t = e ) or ( [t[2],t[1]] = e ) )); od; return tt; end; ########################################################################### ## AddTrivialRelations( , ) adds ## "trivial" relations when analysing a coxeter graph, ## i.e. relations of the form (g_i)^2. ## AddTrivialRelations := function( genlist, rellist ) local i; for i in genlist do Add(rellist, [[i],[0,2]]); od; return( rellist ); end; ########################################################################### ## AddNonEdgeRelations( , , ) adds ## relations of the form (gh)^2 with g and h two ## generators in a coxeter graph that are not joined ## by an edge. ## AddNonEdgeRelations := function( genlist, edges, rellist ) local ttd, i; ttd := TwoTupleDifference( genlist, edges ); for i in ttd do Add( rellist, [[i[1], i[2]], [0,2]]); od; return( rellist ); end; ########################################################################### ## DeCox( ) analyses a path from a ## Coxeter Graph. It returns a list of three entries: ## the first one is list of generators [m,...,n]; ## the second one is a list of relations explicitly ## introduced in this path via an edge and a label; ## the third one is the list of non-edges. ## DeCox := function( string ) local started, rels, gens, newrel, z, abs, pow, abgen, edges, numlist, pos, ln, number, n, look; abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; pow := "1234567890"; started := 0; rels := []; gens := []; newrel := [[],[]]; edges := []; pos := 1; while pos <= Length(string) do z := string[pos]; if z in abs then ## get the generator abgen := Position(abs,z); ## Add new generator to generator list Add(gens,abgen); ## finish the old relation if started = 1 then newrel[1][2] := abgen; Add(rels, newrel); Add(edges, [newrel[1][1],newrel[1][2]]); newrel := [[],[]]; newrel[1][1] := abgen; else started := 1; newrel[1][1] := abgen; fi; pos := pos + 1; else numlist := []; while z in pow do Add( numlist, Position(pow,z) ); pos := pos + 1; z := string[pos]; od; ln := Length(numlist); number := 0; for n in [1..ln] do look := numlist[ln + 1 - n]; if not look = 10 then number := number + look*10^(n-1); fi; od; newrel[2] := [0,number]; fi; od; gens := Set(gens); return( [gens, rels, edges] ); end; ########################################################################### ## Divides the string into pieces, according to ## the places of the comma's. ## MakeStringList := function( string ) local stringlist, newel, i; stringlist := []; newel := ""; for i in string do if i = ',' then Add( stringlist, newel ); newel := ""; else Add( newel, i ); fi; od; Add( stringlist, newel ); return stringlist; end; ########################################################################### ## DeCoxList( Returns a list of length 2. The first entry is ## a list of the generators, introduced by the Coxeter graph , ## the second entry contains the encoded form of the relations ## defined by . ## DeCoxList := function( string ) local coxgens, coxrels, coxedges, cox, coxinfo, stringlist; stringlist := MakeStringList( string ); coxgens := []; coxrels := []; coxedges := []; for cox in stringlist do coxinfo := DeCox( cox ); UniteSet( coxgens, coxinfo[1] ); UniteSet( coxrels, coxinfo[2] ); UniteSet( coxedges, coxinfo[3] ); od; coxrels := AddTrivialRelations( coxgens, coxrels ); coxrels := AddNonEdgeRelations( coxgens, coxedges, coxrels ); return( [coxgens, coxrels] ); end; ########################################################################### ## ToGapWord( ) will encode a list of letters ## as a list of letter-positions in the Latin alphabet. ## a list of numbers will be encoded as a list of numbers, but with an ## extra 0 on the first position: ## ex.: "12" -> [0,12] ## ToGapWord := function( string ) local ll, abs, ch, pow, numlist, nummer, dig, minus, eword; abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; pow := "1234567890"; ll := Length( string ); if ll = 0 then return []; fi; if string[1] in abs then eword := List( [1..ll], ch -> Position( abs, string[ch] )); if false in eword then Error("syntax error, unexpected input in relation"); else return eword; fi; fi; numlist := [0]; if string[1] = '-' then minus := 1; string := Sublist( string, [2..ll]); ll := ll - 1; fi; nummer := 0; for ch in [1..ll] do dig := Position( pow, string[ll - ch + 1] ); if dig = false then Error("syntax error, unexpected input in relation"); fi; if dig < 10 then nummer := nummer + (10^(ch-1))*dig; fi; od; if IsBound(minus) then nummer := -1*nummer; fi; Add( numlist, nummer); return numlist; end; ########################################################################### ## FindOperators( ) will look for operators, but only ## free one's (outside brackets '()' ) ## FindOperators := function( string ) local i, opslist, brdepth; opslist := []; brdepth := 0; for i in [1..Length(string)] do if string[i] = '(' then brdepth := brdepth + 1; elif string[i] = ')' then brdepth := brdepth - 1; elif string[i] = '^' and brdepth = 0 then Add(opslist, i); fi; od; return opslist; end; ########################################################################### ## LHS( ) will determine the LeftHandSide of the operator ## LHS := function( string ) local abs, ll, v, ch, openbr, res; abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; ll := Length(string); v := string[ll]; ch := Position( abs, v ); if not ch = false then res := ""; Add( res, v); return(res); fi; openbr := Position( string , '('); return( Sublist( string, [(openbr + 1 )..(ll - 1)])); end; ########################################################################### ## CorrespondingBracket( ) will return the position ## of the bracket that pairs with the first bracket of . ## CorrespondingBracket := function( string ) local i, br; br := 0; if string[1] = '(' then for i in [1..Length( string )] do if string[i] = '(' then br := br + 1; elif string[i] = ')' then br := br - 1; fi; if br = 0 then return i; fi; od; Error("syntax error, maybe misplaced bracket"); else Error( "Unexpected input ... " ); fi; end; ########################################################################### ## RHS( ) will determine the RightHandSide of the operator ## RHS := function( string ) local res, abs, pow, v, ch, number, w, closebr, ll; abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; pow := "1234567890"; v := string[1]; ch := Position( abs, v ); if not ch = false then res := ""; Add( res, v); return(res); fi; ch := Position( pow, v ); if not ch = false then number := ""; Add( number, v); w := 2; ll := Length(string); while w <= ll and (not Position(pow,string[w]) = false) do Add( number, string[w] ); w := w + 1; od; return number; fi; closebr := CorrespondingBracket( string ); return( Sublist( string, [2..(closebr-1)])); end; ########################################################################### ## ConCat( adds [] iff Length(list) > 0. ## ConCat := function( list ) if Length( list ) > 0 then Add( list, []); fi; return list; end; ########################################################################### ## RemoveBlanks( ) removes all blanks from a string ## RemoveBlanks := function( string ) local newstring, i; newstring := ""; for i in string do if not i = ' ' then Add( newstring, i); fi; od; return newstring; end; ########################################################################### ## RemoveRedundantBrackets( ) removes ## syntactically redundant brackets. ## RemoveRedundantBrackets := function( string ) local ll, ch, newstring, j, i, brlist, red; ll := Length( string ); brlist := []; if ll > 2 then for ch in [1..(ll-2)] do if string[ch] = '(' and string[ch+2] = ')' then Add( brlist, ch); fi; od; if not brlist = [] then newstring := []; j := 1; for i in [1..ll] do if not ( i in brlist or (i-2) in brlist ) then newstring[j] := string[i]; j := j + 1; fi; od; if Length( newstring ) < Length( string ) then newstring := RemoveRedundantBrackets( newstring ); fi; string := newstring; fi; fi; ## Look also for brackets at the begin and end: while ll > 0 and string[1] = '(' and CorrespondingBracket(string) = ll do string := Sublist( string, [2..(ll-1)] ); ll := ll - 2; od; return string; end; ########################################################################### ## MakeWordList( ) will reduce the complexity of the ## word represented by < string > via the following steps: ## 1. If = in string then obviously W ~ 'w1=w2'. ## return E(w1)^(-1).E(w2) ## 2. Determine the list of operators outside brackets ## a. if list is empty -> compl. = 0, EXIT ## 3. Determine the LHS and the RHS of all found operators. ## This will lead to a de decomposition ## w_1.lhs_1.rhs_1.w_2...w_n.lhs_n.rhs_n.w_n+1 ## in words of smaller complexity. ## MakeWordList := function( string ) local ispos, leftrest, opslist, word, i, lhs, rhs, abs, pow, lb, bpos, epos, w1, word, w2, w3; lb := 1; ## left-boundary abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; pow := "1234567890"; word := []; ispos := Position( string, '=' ); if not ispos = false then return [ [ MakeWordList( Sublist( string, [1..(ispos - 1)] ) ), [0,-1] ], [], MakeWordList( Sublist( string, [(ispos + 1)..Length(string)] ) ) ]; fi; string := RemoveRedundantBrackets( string ); opslist := FindOperators( string ); if opslist = [] then if not '(' in string then return ToGapWord( string ); else ## Error("sorry, not ready yet"); bpos := Position( string, '('); epos := CorrespondingBracket( Sublist( string, [bpos..Length(string)])); epos := epos + bpos - 1; if bpos > 1 then w1 := Sublist( string, [1..(bpos - 1)]); word := [ToGapWord( w1 )]; word := ConCat( word ); fi; w2 := Sublist( string, [(bpos + 1)..(epos - 1)]); if IsBound( w1 ) then Add( word, MakeWordList( w2 )); else word := MakeWordList( w2 ); fi; if epos < Length( string ) then w3 := Sublist( string, [(epos + 1)..Length(string)] ); word := ConCat(word); Add( word, MakeWordList( w3 )); fi; ## splits woord in w1(w2)w3 return word; fi; fi; for i in opslist do lhs := LHS( Sublist( string, [lb..(i-1)] ) ); if Length(lhs) = 1 then leftrest := Sublist( string, [lb..(i-2)] ); else leftrest := Sublist( string, [lb..(i-1-2-Length(lhs))] ); fi; if Length( leftrest ) > 0 then word := ConCat( word ); Add( word, ToGapWord( leftrest )); fi; rhs := RHS( Sublist( string, [(i+1)..Length(string)] ) ); word := ConCat( word ); Add( word, [ MakeWordList( lhs ), MakeWordList( rhs ) ] ); if Length(rhs) = 1 then lb := i + 1 + 1; else lb := i + 1 + 2 + Length(rhs); fi; od; if lb <= Length(string) then word := ConCat(word); Add(word, ToGapWord( Sublist( string, [lb..Length(string)] ) ) ); fi; while Length(word) = 1 do word := word[1]; od; return word; end; ########################################################################### ## ListDepth( ). The list depth of a list is defined as ## the maximum amount of steps to take in a list to reach a ## non-list element. ## ex: ListhDepth( 3 ) = 0 ## ListhDepth( [[3]] ) = 2 ## ListhDepth( [[[3]], a] ) = 3 ## ListDepth := function( object ) local ld, cd, ch; ld := 0; cd := 0; object := String( object ); for ch in object do if ch = '[' then cd := cd + 1; ld := Maximum( ld, cd); elif ch = ']' then cd := cd - 1; fi; od; return ld; end; ########################################################################### ## DecodeRel( , ) brings down the complexity ## of the expression by applying one of the following ## (disjoint) rules: ## (R0.) Remove redundant brackets. ## R1. Length(relation) = 2 /\ IsList(relation[1]) ## R2. [] in relation. ## R3. ListDepth(relation) = 1. ## When R3 occurs we are at the bottom and can use one other rule ## to test if we are dealing with a list of letters or a list of ## numbers. ## R3ext. relation[1] = 0 <=> numbers. ## DecodeRel := function( group, relation ) local result, w; result := IdWord; ## R(-1) If the word is a concatenation of a letter on the first ## position and an other complicated word, this situation occurs ## like mw := [ 3, [ ], [ [ 4 ], [ 5 ] ] ]. if not IsList( relation ) then if IsBound( group.(relation) ) then result := group.(relation)*result; return result; else Error("syntax error, maybe wrong generator"); fi; fi; ## R0 while Length(relation) = 1 and IsList( relation[1] ) do relation := relation[1]; od; ## R1 if Length( relation ) = 2 then if IsList( relation[1] ) then result := DecodeRel(group,relation[1])^DecodeRel(group,relation[2]); fi; fi; ## R2 if [] in relation then for w in relation do if not w = [] then result := result * DecodeRel( group, w ); fi; od; fi; ## R3 if ListDepth( relation ) = 1 then ## R3ext if relation[1] = 0 then ## a list with a number in it will always be like [0,n] result := relation[2]; else for w in relation do if IsBound( group.(w) ) then result := result*group.(w); else Error("syntax error, maybe wrong generator" ); fi; od; fi; fi; ## return result; end; ########################################################################### ## IsCoxeterGraph( )returns true if it is likely ## that is a coxeter-graph. Likely means: ## 1. The argument passed is a string. ## 2. the string contains letters and numbers only. ## 3. The string starts with one letter followed by a number. ## IsCoxeterGraph := function( str ) local pow; pow := "1234567890"; if IsString( str ) then if Length( str ) > 0 then if ( str[1] >= 'A' and str[1] <= 'Z' ) or ( str[1] >= 'a' and str[1] <= 'z' ) then if Length(str) > 1 and str[2] in pow then return true; fi; fi; fi; fi; return false; end; ########################################################################### ## GetGenerators( , ) adds every letter once ## to that is in but not in . ## GetGenerators := function( string, used ) local pow, i, used, abs; pow := "1234567890"; abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; ## A Coxeter graph consists of numbers, komma's and letters for i in string do if ( not i in pow ) and ( not i = ',' ) then if not i in used then if i in abs then Add( used, i); else Error("Cannot handle symbol ", i); fi; fi; fi; od; return used; end; ########################################################################### ## GeneratorMap( , ) relabels the ## Coxeter graph by mapping every new letter-generator ## to the smallest letter not yet used from the string ## declared by the local variable abs. ## GeneratorMap := function( string, map ) local i, abs, pos; abs := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; for i in [1..Length(string)] do pos := Position( map, string[i] ); if not pos = false then string[i] := abs[pos]; fi; od; return string; end; ########################################################################### ## IsGeneratorString( string ) returns true iff is a generator ## string. ## IsGeneratorString := function( string ) local stringlist, i; if not IsString( string ) then return false; fi; if not Length( string ) > 0 then return false; fi; stringlist := MakeStringList( string ); if ForAll( stringlist, i -> Length(i) = 1 ) then if ForAll( stringlist, i -> ( 'A' <= i[1] and i[1] <= 'Z' ) or ( 'a' <= i[1] and i[1] <= 'z' ) ) then return true; fi; fi; return false; end; ########################################################################### ## FpGroupViaStrings( ) returns the finitely presented group generated ## by the generators found in '' and/or in '' and subjected ## to the relations defined by '' and/or by ''. ## FpGroupViaStrings := function( arg ) local x, gens, relations, ll, coxinfo, F, rel, FmodR, rels, genstrings; if arg = [] then Error(" must be a list of strings or a number of strings"); fi; if not IsString( arg[1] ) then if IsList( arg[1] ) then arg := Copy( arg[1] ); else Error(" must be a list of strings or a number of strings"); fi; fi; if false in List( arg, x -> IsString( x )) then Error( "arguments must be strings or a list of strings" ); fi; arg := List( arg, x -> RemoveBlanks(x)); ll := Length( arg ); relations := []; genstrings := 0; ## 1. Get the generators if IsCoxeterGraph( arg[1] ) then gens := GetGenerators( arg[1], [] ); arg[1] := GeneratorMap( arg[1], gens ); coxinfo := DeCoxList( arg[1] ); genstrings := 1; if Length( arg ) > 1 then if IsGeneratorString( arg[2] ) then gens := GetGenerators( arg[2], gens ); genstrings := 2; fi; fi; elif IsGeneratorString( arg[1] ) then gens := GetGenerators( arg[1], [] ); genstrings := 1; else Error( " must start with coxeter graph or explicit generators"); fi; F := FreeGroup( Length( gens )); ## 2. Get the relators from the coxeter graph. if IsBound( coxinfo ) then for rel in coxinfo[2] do Add( relations, DecodeRel( F, rel )); od; fi; ## 3. Get the relators from relstring and extrarelstring if ll > 1 then if genstrings = 1 then rels := MakeStringList( arg[2] ); if (not "_PCE" in rels) or ("_PCE" in rels and GPL_PCE = true) then rels := Filtered( rels, n -> not ( n = "_PCE" )); for rel in rels do rel := GeneratorMap( rel, gens ); Add( relations, DecodeRel( F, MakeWordList(rel))); od; fi; fi; if ll > 2 then rels := MakeStringList( arg[3] ); if (not "_PCE" in rels) or ("_PCE" in rels and GPL_PCE = true) then rels := Filtered( rels, n -> not ( n = "_PCE" )); for rel in rels do rel := GeneratorMap( rel, gens ); Add( relations, DecodeRel( F, MakeWordList(rel))); od; fi; if ll = 4 and GPL_PCE = true then rels := MakeStringList( arg[4] ); rels := Filtered( rels, n -> not ( n = "_PCE" )); for rel in rels do rel := GeneratorMap( rel, gens ); Add( relations, DecodeRel( F, MakeWordList(rel))); od; fi; fi; fi; FmodR := F / relations; Print("## The map is: \"",gens,"\"\n"); return FmodR ; end; ########################################################################### ## SubgroupViaStrings( , , ) returns ## the subgroup generated by the words present in ## of the group . indicates in which ## order the generators where introduced in the definition ## of the parent group . ## SubgroupViaStrings := function(arg) local elements, info, el, words, map; if ( not IsGroup( arg[1] )) or ( not IsBound(arg[1].isFpGroup)) then Error( " must be a finitely presented group" ); fi; if ( not IsString( arg[2] )) then Error(" must be a non-empty string"); fi; words := Copy(arg[2]); words := RemoveBlanks(words); if IsBound( arg[3] ) then if ( not IsString( arg[3] )) or ( Length( arg[3] ) <> Length(arg[1].generators )) then Error(" must be a string of the right size"); fi; map := Copy(arg[3]); map := RemoveBlanks(map); words := GeneratorMap( words, map); fi; elements := []; info := MakeStringList( words ); for el in info do Add( elements, DecodeRel( arg[1], MakeWordList(el))); od; return Subgroup( arg[1], elements ); end; ########################################################################### ## ## ## ########################################################################### GPLTableOps := rec(); GPLTableOps.Print := function ( r ) Print( "GroupRecordGPL( \"", r.info[1], "\" )" ); end; ########################################################################### ## GroupRecordGPL( ) ## GroupRecordGPL := function( grname ) if IsString( grname ) then if IsBound( GPLTable.(grname) ) then GPLTable.(grname).operations := GPLTableOps; return GPLTable.(grname); else Error( "no GPL table with name '", grname, "'" ); fi; else Error( "Usage: SporadicGroup( )" ); fi; end; ########################################################################### ## GpOps := rec(); GpOps.Print := function( r ) Print( "GroupPresentationGPL( ", "\"", r.name, "\"", ", ", r.number," )" ); end; ########################################################################### ## GroupPresentationGPL := function( grname, number ) local gprecord, pres, preslist; if not IsString( grname ) or not IsInt( number ) then Error( "usage: GroupPresentationGPL( , )" ); fi; if not IsBound(GPLTable.(grname)) then Error( "no GPL table with name '", grname, "'" ); elif not IsBound(GPLTable.(grname).(number)) then Error( "no presentation ", grname,".",number ); fi; pres := GPLTable.(grname).(number); preslist := Copy( pres.presdef ); gprecord := rec( name := grname, number := number, operations := GpOps, stringPresentation := preslist, subgroups := pres.subgroups, text := pres.text ); return gprecord; end; ########################################################################### ## IsPresentationGPL := function( test ) if IsRec( test ) then if IsBound( test.stringPresentation ) then return true; fi; fi; return false; end; ########################################################################### ## InitializeGroupPresentationGPL := function( gp ) local defining, coxinfo, F, FP, relations, rel, gens, rel3, rel4, extragen, preslist; if not IsPresentationGPL( gp ) then Error( " must be a GPL group presentation"); fi; preslist := Copy( gp.stringPresentation ); if IsBound( preslist[1] ) then defining := Copy(preslist[1]); defining := RemoveBlanks(defining); else defining := ""; fi; if Length( preslist ) > 2 and IsBound( preslist[3] ) then rel3 := Copy(preslist[3]); rel3 := RemoveBlanks(rel3); rel3 := MakeStringList( rel3 ); else rel3 := []; fi; if Length( preslist ) > 3 and GPL_PCE then rel4 := Copy(preslist[4]); rel4 := RemoveBlanks(rel4); rel4 := MakeStringList( rel4 ); else rel4 := []; fi; gens := GetGenerators( defining, [] ); defining := GeneratorMap( defining, gens ); coxinfo := DeCoxList( defining ); if IsBound( preslist[2] ) then extragen := Copy(preslist[2]); extragen := RemoveBlanks( extragen ); gens := GetGenerators( extragen, gens ); fi; F := FreeGroup( Length(gens)); relations := []; for rel in coxinfo[2] do Add( relations, DecodeRel( F, rel)); od; for rel in rel3 do rel := GeneratorMap( rel, gens ); Add( relations, DecodeRel( F, MakeWordList(rel))); od; for rel in rel4 do rel := GeneratorMap( rel, gens ); Add( relations, DecodeRel( F, MakeWordList(rel))); od; FP := F / relations; FP.name := Copy( gp.name ); gp.group := FP; gp.stringGenerators := gens; end; ########################################################################### ## GroupPresentationsGPL( grname ) returns a list of all available group ## presentations for the group with name . ## GroupPresentationsGPL := function( grname ) local press, i; if not IsString( grname ) then Error( "usage: GroupPresentationsGPL( )" ); fi; if not IsBound(GPLTable.(grname)) then Error( "no GPL table with name '", grname, "'" ); fi; press := []; for i in [1..GPLTable.(grname).presentations] do Add( press, GroupPresentationGPL( grname, i) ); od; return press; end; ########################################################################### ## AvailableGroupPresentationsGPL() returns a list of all available group ## presentations AvailableGroupPresentationsGPL := function() return(Flat(List(RecFields(GPLTable), x -> GroupPresentationsGPL(x)))); end; ########################################################################### ## SubgroupGPL := function( arg ) local names, i, sg, p; p := arg[1]; if not IsPresentationGPL( p ) then Error( " must be a GPL group presentation" ); fi; if not IsBound( p.group ) then Error("first initialize presentation via ", "InitializeGroupPresentationGPL( )"); fi; if IsInt( arg[2] ) then i := arg[2]; if i <= Length( p.subgroups ) and i > 0 then sg := SubgroupViaStrings( p.group, p.subgroups[i][2],\ arg[1].stringGenerators ); sg.name := p.subgroups[i][1]; return sg; else Error( "Enter a number between 1 and ", Length( p.subgroups ) ); fi; elif IsString( arg[2] ) then names := List( p.subgroups, x -> x[1] ); i := Position( names, arg[2]); if not ( i = false ) then sg := SubgroupViaStrings( p.group , p.subgroups[i][2],\ p.stringGenerators ); sg.name := p.subgroups[i][1]; return sg; else Error( "no subgroup with name ", arg[2] ); fi; else Error( "usage: SubgroupGPL( , )" , "\n", "resp. SubgroupGPL( , )" ); fi; end; ########################################################################### ## AvailableSubgroupsGPL := function( pres ) local ll, sg, i; if not IsPresentationGPL( pres ) then Error( " must be a GPL group presentation" ); fi; ll := Length( pres.subgroups ); sg := []; for i in [1..ll] do Add( sg, SubgroupGPL( pres, i)); od; return sg; end; ########################################################################### ## AvailableMaximalSubgroupsGPL := function( pres ) local ll, sg, i; if not IsPresentationGPL( pres ) then Error( " must be a GPL group presentation" ); fi; ll := Length( pres.subgroups ); sg := []; for i in [1..ll] do if not "_MF" in pres.subgroups[i] then Add( sg, SubgroupGPL( pres, i)); fi; od; return sg; end; ###################################################################### ## StringDigit( ) converts the number in a string. ## StringDigit := function( number ) local pow, str, i, next, number; pow := "123456789"; str := ""; i := 1; while number > 0 do next := number mod 10; number := (number - next)/10; if next > 0 then Add( str, pow[next] ); else Add( str, '0'); fi; od; return Reversed(str); end; ####################################################################### ## FindPowersInWord( ) collect terms in words represented ## by strings, e.g. "aaaaaaaa" -> "(a)^8". ## FindPowersInWord := function( wordstring ) local times, l, i, pat, j, powword, epat, eval, bpat; l := Length(wordstring); if l < 6 then return wordstring; else times := 1; for i in [1..QuoInt(l,2)] do pat := Sublist(wordstring, [1..i]); j := i+1; while j < l do if pat = Sublist(wordstring, [j..(j+i-1)]) then times := times + 1; j := j + i; else j := l; fi; od; if times > 1 then powword := "("; Append( powword, FindPowersInWord( pat )); ## Append( powword, pat ); Append( powword, ")^" ); Append( powword, StringDigit( times )); if times*i < l then Append( powword, FindPowersInWord( Sublist( wordstring, [times*i+1..l]))); fi; return powword; fi; od; bpat := ""; epat := Copy( wordstring ); while l > 6 do Add( bpat, epat[1] ); epat := Sublist( epat, [2..l] ); eval := FindPowersInWord( epat ); if eval = epat then l := l-1; else Append( bpat, eval ); return bpat; fi; od; fi; return wordstring; end; ####################################################################### ## FpWordToString( , , ) converts an ## GAP word in a stringword.` ## FpWordToString := function( word, generators, ext ) local alphabet, wordstring, i, gen, invgen, next; alphabet := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; wordstring := ""; gen := Copy( generators ); invgen := List( gen, x -> x^-1 ); for i in [1..LengthWord( word )] do next := Subword(word,i,i); if next in invgen then Add(wordstring, alphabet[Position(invgen,next)]); Append(wordstring, "^(-1)"); else Add( wordstring, alphabet[Position(gen,next)]); fi; od; if ext then return FindPowersInWord(wordstring); else return wordstring; fi; end; ####################################################################### ## StringPresentation( group ) returns a very basic string presentation ## of the group . ## StringPresentation := function( group ) local i, l, stringgenerators, stringrel, alphabet, j; if not IsBound( group.isFpGroup ) then Error( " must be a finitely presented group" ); fi; alphabet := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; l := Length( group.generators ); stringgenerators := ""; for i in [1..l] do if i > 1 then Append( stringgenerators, ","); fi; Add(stringgenerators, alphabet[i]); od; stringrel := ""; for j in [1..Length(group.relators)] do if j > 1 then Append(stringrel, ","); fi; Append(stringrel, FpWordToString(group.relators[j], group.generators, false )); od; return [ String(stringgenerators), String(stringrel) ]; end; ###################################################################### ## NrGeneratorsInWord( , ) returns the number of ## generators in the GAP word < word>. ## NrGeneratorsInWord := function( word, gen ) local nr, i; nr := 0; for i in gen do if ( not ( PositionWord( word, i) = false ) ) or ( not ( PositionWord( word, i^(-1) ) = false ) ) then nr := nr + 1; fi; od; return nr; end; ###################################################################### ## ReverseWord( ) returns the reversed of . ## ReversedWord := function( word ) local rev, l, i; rev := IdWord; l := LengthWord( word ); for i in [1..l] do rev := rev*Subword( word, l-i+1, l-i+1); od; return rev; end; ###################################################################### ## ListToString( ) converts a list of letters in a string. ## ListToString := function( list ) local str, i; str := ""; for i in [1..Length(list)-1] do Append(str, list[i]); Add(str, ','); od; Append(str, list[Length(list)]); return( String(str) ); end; ###################################################################### ## JoinCoxPaths( arg ) takes a list or a string, representing paths ## in a Coxeter graph as its argument and tries to join paths in a few ## ways. ## JoinCoxPaths := function( arg ) local coxpaths, l, match, i, j, b, e, nc; if IsString( arg[1] ) then coxpaths := MakeStringList( arg[1] ); else coxpaths := Copy(arg[1]); fi; l := Length( coxpaths ); if Length( coxpaths ) = 1 then return ListToString(coxpaths); fi; match := []; for i in [1..(l-1)] do for j in [(i+1)..l] do if coxpaths[i][1] = coxpaths[j][Length(coxpaths[j])] then Add( match, [i,j] ); fi; od; od; if match = [] then return( ListToString(coxpaths)); fi; b := match[1][1]; e := match[1][2]; Append( coxpaths[e], Sublist( coxpaths[b], [2..Length(coxpaths[b]) ] ) ); nc := Copy( Sublist( coxpaths, [1..(b-1)])); Append( nc , Sublist( coxpaths, [b+1..l]) ); coxpaths := Copy( nc ); if Length( match ) = 1 then return( ListToString(coxpaths)); else return( JoinCoxPaths(coxpaths) ); fi; end; ###################################################################### ## CoxString( gen, coxrel ) returns a string representing a Coxeter ## graph from the vertices and the edges with labels . ## CoxString := function( gen, coxrel ) local alphabet, r, curstring, l, join, starts, pos, pos2, starts2; alphabet := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; coxrel := Set( coxrel ); r := coxrel[1]; curstring := ""; Add( curstring, alphabet[Position( gen, Subword( r, 1, 1))] ); l := LengthWord( r )/2; Append( curstring, StringDigit(l)); join := Subword( r, 2, 2); Add( curstring, alphabet[Position( gen, join )]); SubtractSet( coxrel, [r]); while Length( coxrel ) > 0 do pos2 := false; starts := List( coxrel, x -> Subword( x, 1, 1)); ## slow pos := Position( starts, join); if not pos = false then r := coxrel[pos]; else starts2 := List( coxrel, x -> Subword( x, 2, 2)); pos2 := Position( starts2, join); if not pos2 = false then r := ReversedWord( coxrel[pos2] ); else ## start next string Add( curstring, ','); r := coxrel[1]; Add( curstring, alphabet[Position( gen, starts[1])]); fi; fi; l := LengthWord( r )/2; Append( curstring, StringDigit(l)); join := Subword( r, 2, 2); Add( curstring, alphabet[Position( gen, join )]); if not pos2 = false then SubtractSet( coxrel, [coxrel[pos2]] ); else SubtractSet( coxrel, [r]); fi; od; return JoinCoxPaths( curstring ); end; ##################################################################### ## CoxeterStringPresentation( ) returns a stringpresentation ## of the group . As much as possible of the presentation ## will be stored in a Coxeter graph. ## ## ** This procedure requires the package Grape. ** ## CoxeterStringPresentation := function( group ) local gen, rel, twogen, ntwogen, g, invtwogen, invntwogen, notcoxrel, maybecox, r, done, nr, p, comb, twoprod, i, s, l, test, nrtwogen, adjmat, graph, i1, i2, compsgraph, max, evalcox, notcoxgen, coxstring, alphabet, extragen, pres, stringrel; if not IsBound( group.isFpGroup ) then Error( " must be a finitely presented group" ); fi; alphabet := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; gen := Copy( group.generators ); if IsBound( group.relators ) then rel := Copy( group.relators ); else ## Free Group rel := []; fi; twogen := []; ntwogen := []; for g in gen do if g^2 in rel then Add( twogen, g ); else Add( ntwogen, g ); fi; od; if Length( twogen ) = 1 then Append( ntwogen, twogen ); twogen := []; fi; invtwogen := List( twogen, x -> x^(-1) ); invntwogen := List( ntwogen, x -> x^(-1)); notcoxrel := []; maybecox := []; for r in rel do done := false; ## only involutions in coxeter graph. for g in [1..Length(ntwogen)] do if not done then if not PositionWord( r, ntwogen[g]) = false or not PositionWord( r, invntwogen[g]) = false then Add( notcoxrel, r); done := true; fi; fi; od; ## a = a^-1 <= a^2 = 1 for g in invtwogen do p := PositionWord( r, g); while not ( p = false ) do r := SubstitutedWord( r, p,p,g^(-1)); p := PositionWord( r, g); od; od; ## maximal two different generators. if not done then nr := NrGeneratorsInWord( r, twogen ); if nr > 2 then Add( notcoxrel, r); done := 1; elif nr = 1 then done := 1; elif LengthWord(r) mod 2 = 1 then Add( notcoxrel, r); done := 1; else ## coxword should be of the form (ab)^m, m > 1. comb := Combinations( twogen, 2); twoprod := []; for i in comb do Add( twoprod, i[1]*i[2] ); Add( twoprod, i[2]*i[1] ); od; s := Subword(r, 1,2); l := LengthWord( r ); if l = 2 then Add( notcoxrel, r); else test := List( [1..(l/2)], x -> s = Subword( r, 2*x-1,2*x)); if false in test then Add( notcoxrel, r); else Add( maybecox, r); fi; fi; fi; fi; od; nrtwogen := Length( twogen ); if nrtwogen > 1 then adjmat := List( [1..nrtwogen], x -> List([1..nrtwogen], x -> 0)); for i in maybecox do i1 := Position( twogen, Subword( i, 1, 1)); i2 := Position( twogen, Subword( i, 2, 2)); adjmat[i1][i2] := 1; adjmat[i2][i1] := 1; od; graph := Graph( Group(()), [1..Length(twogen)], OnPoints, function(x,y) return adjmat[x][y] = 1; end, true ); compsgraph := CompleteSubgraphs( graph ); i := List( compsgraph, x -> Length(x)); max := Maximum( i ); compsgraph := compsgraph[Position(i, max)]; ## swap notcox-relations from maybecox to notcoxrel if Length(compsgraph) < Length(twogen) then notcoxgen := [1..Length(twogen)]; SubtractSet( notcoxgen, compsgraph ); notcoxgen := List( notcoxgen, i -> twogen[i] ); maybecox := Set( maybecox ); evalcox := Copy( maybecox ); for g in notcoxgen do Add( notcoxrel, g^2 ); for r in maybecox do if not PositionWord( r, g ) = false then Add( notcoxrel, r ); SubtractSet( evalcox, [r] ); fi; od; od; Append( ntwogen, notcoxgen ); fi; fi; if IsBound( evalcox ) then maybecox := Copy( evalcox); fi; stringrel := ""; for i in notcoxrel do if nrtwogen = Length( gen ) then Append( stringrel, FpWordToString( i, gen, true )); else Append( stringrel, FpWordToString( i, gen, false )); fi; Add( stringrel, ','); od; if not stringrel = "" then Unbind( stringrel[Length(stringrel)] ); fi; maybecox := Filtered( maybecox, i -> LengthWord(i) > 4 ); if Length( maybecox ) > 0 then coxstring := CoxString( gen, maybecox ); fi; pres := []; if IsBound( coxstring ) then pres[1] := String( coxstring ); fi; if IsBound( stringrel ) then pres[3] := String( stringrel ); fi; if Length( ntwogen ) > 0 then ntwogen := Set( ntwogen ); extragen := ""; for i in [1..Length(ntwogen)] do if i > 1 then Add( extragen, ','); fi; Add( extragen, alphabet[Position( gen, ntwogen[i] )]); od; pres[2] := String(extragen); fi; return pres; end; ########################################################################### ## ## END ##