The recog package Max Horn University of Siegen WARNING! This - PowerPoint PPT Presentation

1 July 2019 The recog package Max Horn 
 University of Siegen

WARNING! This talk contains very little math

Some background

What is recog and why does it matter? ❖ recog is a GAP package ❖ recog implements {matrix, permutation, black box}- group recognition ❖ many computational research problems hinge on having access to effective group recognition ❖ only (?) matrix group recognition implementation outside of Magma ❖ fully operational recog is crucial for GAP and beyond

What happened so far … ❖ recog authors: Ákos Seress and Max Neunhöffer ❖ 2013 was a bad year: Ákos died; Max left academia ❖ since then, no major work was done on recog ❖ (some minor work by me: bug fixes, documentation, …) ❖ lots is missing in recog – but we need it! ❖ who is going to do the work?

… and your students, friends, … – spread the word!

How does it work?

How does recognition work, roughly? ❖ Input: set � of generators (permutations, matrices, …) X ❖ Output: ❖ order of � , name of � G := ⟨ X ⟩ G ❖ new generating set � , Y ❖ procedure to express any � as word (SLP) in � g ∈ G Y ❖ Iterate over a catalog of methods to analyze � ; each either G ❖ “reduces” to smaller cases by an epimorphism � , or φ : G → H ❖ handles group directly if “easy” or almost simple

�� �� �� �� <latexit sha1_base64="X7V6hSBLu6O365ki6cwD2jlcw5k=">AagXic1Zhb9s2FMfZS7bWu6XbW/ZCLCm2Aa5ruyhWoHDRJmnSe9Pm0qCxEehC24Rp2ZDkXCrobfuQ+xL7BHvY4RFpJwpjSt1e5oNERyR/f5KH4jFldyx4FNfrf165eu36whdf3rhZ+erb79bvHW93vRaBJ6bNcbiVG47zoREzxguzGPBdsfh8wZuoJ9cAdrsv7DEQsjPgp24tMx6wydXsC73HNiKDq8df2vdswHnyIWJxVK45CxYOSzu7UoPhWMtmjiCN4LWh4LYhZWKQ8CFtKIjVv1cVylMTuJaVbH/CoIUNodBXGrHXW7zpCL01QWulz4ZxR1J1Xq8dATcHWF4w2q1A+d45byUfmY+3G/1aw12bBKYRanNO5zbwCitwuoHvd5DJfzA2q73YiFnEXnupN6MHQuhKH/Ru0+G+JEBiwMLBOZsKmwdJWkdG1TorTnhAE/MXSQVtJKpe2yHg8SuVpj7sWTkKUHdx5VH7WimDki7v9cRaWqYEdMKJFWEnEXHo0e9eFRcgJPyt73hneXG1WKDc9WwES9YdqptGWf9EAGuEOTlc3DxkqKa+v1oSihWbUMBlQ37md1l9bXZ/UX2mQzhlYpZX6P0W4GtKxE8ITRQ98J+ozv/Of4ZeMU02TzulHT+VBOqeR0knzHRpCN4tsc2V+9O49+H9ED6aSBHca6crlWtXsSe9cHNBNBLc7+Smbop1ruWs82DFEPeHlTYL/HM7pnK4uFyv1fFDLzoN5SwT9dka3aq0SJv4ZEQ8MiFDwkhAYvAFcUgEdkAapE7GUNYhCZSF4HGsZyQlFWAn0IpBCwdKB/C/B3cHqjSAe6kZIe1BLwL+QiApuQ1/G6joQmvZKwM/guvf8PcJy3qX9pCgshzhKVxdULyJiq+hPCZ9aGEjh6qlHoudlLOKSZc8wNlwGN8YS+Q8vanOtSEUDbAGkqeYseaLh4fwQRCOC6CyOQUdYKFGfsw9XBK0OVQCk6oBfCVUZfjqcyZ35Zm0+4PlSZbqvrBFxdUJTxP8W18aftbW0jiJIDvcp1rQLpQAuvMC2vIcTgGOls/iO1Gk5hFRkfD58lB9vImEakhrGQqxhiXARGJot/OjdmAkYwUlEPpm2zFWAwVg/HOFRrk0DdE7AUPf0kuWAJlmY74zJyDcxErlnJdTATuW4ln4KZyKdWcgPMRG5YyWdgJvKZlXwJZiJfWslXYCbylZV8DWYiX1vJN2Am8o2VfAtmIt9ayS0wE7lJd+Bmch3VvI9mIl8byU/gpnIj4qszKWfGPZalnWK7LZVNDO9Wmiv5nerpovt1/yO1XSxPZvftZoutm/zO1fT9r27iWamNwvt/Pze17R9z9HM9PrfQLNDP9olDmyeceTRfLPvn8o+liGSifgzRdLAvl85Cmi2WifC7SdLFslM9Hmi6WkfI5SdPFslI+L2nanpm20cz0tpXeQTPTO1Z6F81M71rpPTQzvWel9HM9H6hfJ7P6Jqe5fT56cxMFxpHOG5TpfM61me3KJzVFbC8c1idnJbx/OhUC302f4tnlqzM6M8O2bfLl2wFL9LMq8sv6n2vPbK8gLuMj7zyvKTKT/5DH4VY+ejwswvp7GbwQhasz8shpC8aI06nzfxaHs3fldOS7Wg81tFeWD1QktVeWP1Fz0F45fgNGfYK89srxPbAsn2mvLC/vfaWg/XIaz3DPp3hSyLxyPFf98/o+zmsWoC09sryodoF2ivHv5y+fyZn/HIaA4h89r2gvXL8K3xfTvHEwj+j/eYrbNdNPLaWzj+3k2iplfTiPCMg81Zn75cWiN7X+hMVFPxcwvqyF/G3GVhvbLapyqfaW9cvyO+uUumXpl+QsxOFxcbuR/m7zo7DVrjXu15rvm8uNV9bvlDfIj+Yn8QhrkN/IY8sQWnJe8hd2FZOH3hT+Wri39ulRfamZNr15RzA/k3Gfp4T+xLM72</latexit> The recognition tree G 1 G 2 G n − 1 G n ❖ blue = kernels, white = images ❖ leaves are either easy to handle or almost simple

Writing recognition methods

What is a recognition method? ❖ we start with input � , and reduce to subquotients G = ⟨ X ⟩ ❖ now we study the subquotient � K = ⟨ X K ⟩ ❖ a recognition method is a procedure with two tasks: (1) find new “nice generators” � for � together with a Y K K procedure which expresses any � as SLP in � k ∈ K Y K (2) record how � was derived from � (e.g. via SLPs) Y K X K

Method selection and hints ❖ recog has “database” of recognition methods ❖ methods are ordered by a “rank” ❖ recog tries methods in order of rank, until one succeeds ❖ methods may be retried depending on their return value ❖ methods may pass “hints” to factor and kernel, and also specify additional recognition method

� Methods on a technical level ❖ Input: recognition info record ri and a group G ❖ when run, attempt to resolve the two tasks somehow ❖ if successful: ❖ update ri with new generators � ; function for producing SLP in Y K for any � ; information how to derive � from � (e.g. SLPs) k ∈ K Y K Y K X K ❖ return Success ❖ else return one of … ❖ NeverApplicable or TemporaryFailure or NotEnoughInformation

A trivial example SLPforElementFuncs.TrivialGroup 9= function(ri, g) return StraightLineProgramNC( [ [1,0] ], 1 ); end; FindHomMethodsGeneric.TrivialGroup 9= function(ri, G) local gens; gens 9= GeneratorsOfGroup(G); if not ForAll(gens, ri!.isone) then return NeverApplicable; fi; SetSize(ri, 1); Setslpforelement(ri, SLPforElementFuncs.TrivialGroup); Setslptonice(ri, StraightLineProgramNC([[[1,0]]], Length(gens))); SetFilterObj(ri, IsLeaf); return Success; end; AddMethod(FindHomDbPerm, FindHomMethodsGeneric.TrivialGroup, 300, "TrivialGroup" , "go through generators, compare to identity" );

A branching example ❖ Any example that is not a leaf FindHomMethodsPerm.NonTransitive 9= function(ri, G) node involves a nontrivial local hom, la, o; epimorphism � φ : K → H # Then test whether we can do something: if IsTransitive(G) then ❖ define nice gens of � as union of return NeverApplicable; K fi; nice gens � of � , and Y N N := ker φ la 9= LargestMovedPoint(G); preimages of nice gens � of � Y H H o 9= Orb(G, la, OnPoints); Enumerate(o); hom 9= OrbActionHomomorphism(G, o); ❖ want SLP in � for � : k ∈ K Y K SetHomom(ri, hom); return Success; ❖ express � as SLP in � φ ( k ) Y H end; ❖ evaluate this over � : yields � Y K k ′ � ∈ Nk AddMethod(FindHomDbPerm, FindHomMethodsPerm.NonTransitive, kk ′ � − 1 ❖ express � as SLP in � Y N 90, "NonTransitive" , "try to restrict to orbit" ); ❖ combined we get SLP for k in � Y K

Passing hints to image and kernel FindHomMethodsMatrix.BlockLowerTriangular 9= function(ri, G) # This is only used coming from a hint, we know what to do: # A base change was done to get block lower triangular shape. # We first do the diagonal blocks, then the lower p-part: local H, data, hom, newgens; data 9= rec( blocks 9= ri!.blocks ); newgens 9= List(GeneratorsOfGroup(G), x ]> RECOG.HomOntoBlockDiagonal(data, x)); Assert(0, not fail in newgens); H 9= Group(newgens); hom 9= GroupHomByFuncWithData(G, H, RECOG.HomOntoBlockDiagonal, data); SetHomom(ri, hom); # Give hint to factor forfactor(ri).blocks 9= ri!.blocks; Add(forfactor(ri).hints, rec( method 9= FindHomMethodsMatrix.BlockDiagonal, rank 9= 2000, stamp 9= "BlockDiagonal" ) ); # Give hint to kernel N findgensNmeth(ri).method 9= FindKernelLowerLeftPGroup; findgensNmeth(ri).args 9= []; Add(forkernel(ri).hints, rec( method 9= FindHomMethodsMatrix.LowerLeftPGroup, rank 9= 2000, stamp 9= “LowerLeftPGroup" )); forkernel(ri).blocks 9= ri!.blocks; return Success; end;

What is there and what is missing?

What is there? ❖ a flexible framework for tying together different recognition methods ❖ various recognition methods are already implemented ❖ list in the recog manual ❖ https://gap-packages.github.io/recog/doc/chap6.html

What is missing? ❖ Many old and new methods for recognizing almost simple groups were never implemented ❖ most constructive recognition methods ❖ Verification is not implemented — very important! ❖ need to add presentations to “leaf” nodes / recognition methods ❖ then provide infrastructure to lift these through the recognition tree

What else is missing? ❖ Higher-level methods that rewrite or use recognition tree (see Eamonn’s talk) ❖ Bug fixes ❖ More and better documentation ❖ Tests, tests, tests (import from Magma) ❖ Performance improvements ❖ Infrastructure on the GAP side: faster MeatAxe, MatrixObj (new matrix interface), …

Help wanted! ❖ Anybody who is interested in having group recognition in GAP : please consider contributing to recog ❖ Some ways to help are listed on the summer school website, see also https://bit.ly/recog-tasks

Developer infrastructure ❖ Homepage ❖ https://gap-packages.github.io/recog/ ❖ Source code ❖ https://github.com/gap-packages/recog/ ❖ Issue tracker (bug reports, feature requests, support) ❖ https://github.com/gap-packages/recog/issues/ ❖ Continuous integration / tests ❖ https://travis-ci.org/gap-packages/recog/

References ❖ Max Neunhöffer, Ákos Seress, A data structure for a uniform approach to computations with finite groups , 2006 ❖ Max Neunhöffer, Constructive Recognition of Finite Groups , 2009, habilitation thesis ❖ Henrik Bäärnhielm, Derek Holt, Charles Leedham-Green, Eamonn O’Brien, A practical model for computation with matrix groups , 2014