New upstream version 2.9.1
Jerome Benoit
5 years ago
| 0 | 0 | ############################################################################# |
| 1 | 1 | ## |
| 2 | ## PackageInfo.g for the package `SONATA' Jürgen Ecker | |
| 2 | ## PackageInfo.g for the package `SONATA' Jürgen Ecker | |
| 3 | 3 | ## Erhard Aichinger |
| 4 | ## Franz Binder | |
| 5 | ## Peter Mayr | |
| 6 | ## Christof Nöbauer | |
| 7 | ## | |
| 8 | ## (created from Frank Lübeck's PackageInfo.g template file) | |
| 4 | ## Franz Binder | |
| 5 | ## Peter Mayr | |
| 6 | ## Christof Nöbauer | |
| 7 | ## | |
| 8 | ## (created from Frank Lübeck's PackageInfo.g template file) | |
| 9 | 9 | ## |
| 10 | 10 | ## This is a GAP readable file. Of course you can change and remove all |
| 11 | 11 | ## comments as you like. |
| 14 | 14 | ## the package loading mechanism and the upgrade mechanism for the |
| 15 | 15 | ## redistribution of the package via the GAP website. |
| 16 | 16 | ## |
| 17 | ## Entries that are commented out are those used for the EDIM package | |
| 18 | ## and are there for purposes of illustration of a possible alternative, | |
| 19 | ## especially in the case where the Example package's entry is blank. | |
| 20 | ## | |
| 21 | ||
| 22 | ## For the LoadPackage mechanism in GAP >= 4.4 only the entries | |
| 23 | ## .PackageName, .Version, .PackageDoc, .Dependencies, .AvailabilityTest | |
| 24 | ## .Autoload are needed. The other entries are relevant if the | |
| 25 | ## package shall be distributed for other GAP users, in particular if it | |
| 26 | ## shall be redistributed via the GAP Website. | |
| 27 | ||
| 28 | ## With a new release of the package at least the entries .Version, .Date and | |
| 29 | ## .ArchiveURL must be updated. | |
| 30 | ||
| 31 | 17 | SetPackageInfo( rec( |
| 32 | 18 | |
| 33 | ## This is case sensitive, use your preferred spelling. | |
| 34 | # | |
| 35 | 19 | PackageName := "SONATA", |
| 20 | Subtitle := "System of nearrings and their applications", | |
| 21 | Version := "2.9.1", | |
| 22 | ## Release date of the current version in dd/mm/yyyy format. | |
| 23 | Date := "07/10/2018", | |
| 36 | 24 | |
| 37 | ## This may be used by a default banner or on a Web page, should fit on | |
| 38 | ## one line. | |
| 39 | Subtitle := "System of nearrings and their applications", | |
| 40 | ||
| 41 | ## See '?Extending: Version Numbers' in GAP help for an explanation | |
| 42 | ## of valid version numbers. For an automatic package distribution update | |
| 43 | ## you must provide a new version number even after small changes. | |
| 44 | Version := "2.8", | |
| 45 | ||
| 46 | ## Release date of the current version in dd/mm/yyyy format. | |
| 47 | # | |
| 48 | Date := "29/07/2015", | |
| 49 | ||
| 50 | ## URL of the archive(s) of the current package release, but *without* | |
| 51 | ## the format extension(s), like '.zoo', which are given next. | |
| 52 | ## The archive file name *must be changed* with each version of the archive | |
| 53 | ## (and probably somehow contain the package name and version). | |
| 54 | ## The paths of the files in the archive must begin with the name of the | |
| 55 | ## directory containing the package (in our "example" probably: | |
| 56 | ## example/init.g, ... or example-1.3/init.g, ... ) | |
| 57 | # | |
| 58 | ArchiveURL := | |
| 59 | # "http://www.math.rwth-aachen.de/~Greg.Gamble/Example/example-1.5", | |
| 60 | "http://www.algebra.uni-linz.ac.at/Sonata/sonata-2.8/sonata-2.8", | |
| 61 | ## All provided formats as list of file extensions, separated by white | |
| 62 | ## space or commas. | |
| 63 | ## Currently recognized formats are: | |
| 64 | ## .zoo the (GAP-traditional) zoo-format with "!TEXT!" comments | |
| 65 | ## for text files | |
| 66 | ## .tar.gz the UNIX standard | |
| 67 | ## .tar.bz2 compressed with 'bzip2', often smaller than with gzip | |
| 68 | ## -win.zip zip-format for DOS/Windows, text files must have DOS | |
| 69 | ## style line breaks (CRLF) | |
| 70 | ## | |
| 71 | ## In the future we may also provide .deb or .rpm formats which allow | |
| 72 | ## a convenient installation and upgrading on Linux systems. | |
| 73 | ## | |
| 74 | # ArchiveFormats := ".zoo", # the others are generated automatically | |
| 75 | ArchiveFormats := ".tar.gz", | |
| 76 | ||
| 77 | ## If not all of the archive formats mentioned above are provided, these | |
| 78 | ## can be produced at the GAP side. Therefore it is necessary to know which | |
| 79 | ## files of the package distribution are text files which should be unpacked | |
| 80 | ## with operating system specific line breaks. There are the following | |
| 81 | ## possibilities to specify the text files: | |
| 82 | ## | |
| 83 | ## - specify below a component 'TextFiles' which is a list of names of the | |
| 84 | ## text files, relative to the package root directory (e.g., "lib/bla.g") | |
| 85 | ## - specify below a component 'BinaryFiles' as list of names, then all other | |
| 86 | ## files are taken as text files. | |
| 87 | ## - if no 'TextFiles' or 'BinaryFiles' are given and a .zoo archive is | |
| 88 | ## provided, then the files in that archive with a "!TEXT!" comment are | |
| 89 | ## taken as text files | |
| 90 | ## - otherwise: exactly the files with names matching the regular expression | |
| 91 | ## ".*\(\.txt\|\.gi\|\.gd\|\.g\|\.c\|\.h\|\.htm\|\.html\|\.xml\|\.tex\|\.six\|\.bib\|\.tst\|README.*\|INSTALL.*\|Makefile\)" | |
| 92 | ## are taken as text files | |
| 93 | ## | |
| 94 | ## (Remark: Just providing a .tar.gz file will often result in useful | |
| 95 | ## archives) | |
| 96 | ## | |
| 97 | ## These entries are *optional*. | |
| 98 | #TextFiles := ["init.g", ......], | |
| 99 | #BinaryFiles := ["doc/manual.dvi", ......], | |
| 100 | ||
| 101 | ||
| 102 | ## Information about authors and maintainers. Specify for each person a | |
| 103 | ## record with the following information: | |
| 104 | ## | |
| 105 | ## rec( | |
| 106 | ## # these are compulsory, characters are interpreted as latin-1, so | |
| 107 | ## # German umlauts and other western European special characters are ok: | |
| 108 | ## LastName := "Müller", | |
| 109 | ## FirstNames := "Fritz Eduard", | |
| 110 | ## | |
| 111 | ## # At least one of the following two entries must be given and set | |
| 112 | ## # to 'true' (an entry can be left out if value is not 'true'): | |
| 113 | ## IsAuthor := true; | |
| 114 | ## IsMaintainer := true; | |
| 115 | ## | |
| 116 | ## # At least one of the following three entries must be given. | |
| 117 | ## # - preferably email address and WWW homepage | |
| 118 | ## # - postal address not needed if email or WWW address available | |
| 119 | ## # - if no contact known, specify postal address as "no address known" | |
| 120 | ## Email := "Mueller@no.org", | |
| 121 | ## # complete URL, starting with protocol | |
| 122 | ## WWWHome := "http://www.no.org/~Mueller", | |
| 123 | ## # separate lines by '\n' (*optional*) | |
| 124 | ## PostalAddress := "Dr. F. Müller\nNo Org Institute\nNo Place 13\n\ | |
| 125 | ## 12345 Notown\nNocountry" | |
| 126 | ## | |
| 127 | ## # If you want, add one or both of the following entries (*optional*) | |
| 128 | ## Place := "Notown", | |
| 129 | ## Institution := "Institute for Nothing" | |
| 130 | ## ) | |
| 131 | ## | |
| 132 | 25 | Persons := [ |
| 133 | 26 | rec( |
| 134 | 27 | LastName := "Aichinger", |
| 135 | 28 | FirstNames := "Erhard", |
| 136 | 29 | IsAuthor := true, |
| 137 | 30 | IsMaintainer := true, |
| 138 | Email := "erhard.aichinger@algebra.uni-linz.ac.at", | |
| 139 | WWWHome := "http://www.algebra.uni-linz.ac.at/~erhard/", | |
| 31 | Email := "erhard@algebra.uni-linz.ac.at", | |
| 32 | WWWHome := "https://www.jku.at/institut-fuer-algebra/team/erhard-aichinger/", | |
| 140 | 33 | PostalAddress := Concatenation( [ |
| 141 | "Institut für Algebra\n", | |
| 142 | "Johannes Kepler Universität Linz\n", | |
| 34 | "Institut für Algebra\n", | |
| 35 | "Johannes Kepler Universität Linz\n", | |
| 143 | 36 | "4040 Linz\n", |
| 144 | 37 | "Austria" ] ), |
| 145 | 38 | Place := "Linz", |
| 146 | Institution := "Johannes Kepler Universität Linz" | |
| 39 | Institution := "Johannes Kepler Universität Linz" | |
| 147 | 40 | ), |
| 148 | 41 | rec( |
| 149 | 42 | LastName := "Binder", |
| 153 | 46 | Email := "franz.binder@algebra.uni-linz.ac.at", |
| 154 | 47 | WWWHome := "http://www.algebra.uni-linz.ac.at/~xbx/", |
| 155 | 48 | PostalAddress := Concatenation( [ |
| 156 | "Institut für Algebra\n", | |
| 157 | "Johannes Kepler Universität Linz\n", | |
| 49 | "Institut für Algebra\n", | |
| 50 | "Johannes Kepler Universität Linz\n", | |
| 158 | 51 | "4040 Linz\n", |
| 159 | 52 | "Austria" ] ), |
| 160 | 53 | Place := "Linz", |
| 161 | Institution := "Johannes Kepler Universität Linz" | |
| 54 | Institution := "Johannes Kepler Universität Linz" | |
| 162 | 55 | ), |
| 163 | 56 | rec( |
| 164 | 57 | LastName := "Ecker", |
| 165 | FirstNames := "Jürgen", | |
| 58 | FirstNames := "Jürgen", | |
| 166 | 59 | IsAuthor := true, |
| 167 | 60 | IsMaintainer := false, |
| 168 | Email := "juergen.ecker@algebra.uni-linz.ac.at", | |
| 169 | WWWHome := "http://www.algebra.uni-linz.ac.at/~juergen/", | |
| 170 | PostalAddress := Concatenation( [ | |
| 171 | "Institut für Algebra\n", | |
| 172 | "Johannes Kepler Universität Linz\n", | |
| 173 | "4040 Linz\n", | |
| 174 | "Austria" ] ), | |
| 175 | Place := "Linz", | |
| 176 | Institution := "Johannes Kepler Universität Linz" | |
| 61 | Email := "juergen.fuss@fh-hagenberg.at", | |
| 62 | WWWHome := "http://research.fh-ooe.at/en/staff/113", | |
| 63 | Place := "Hagenberg", | |
| 64 | Institution := "Upper Austria University of Applied Sciences" | |
| 177 | 65 | ), |
| 178 | 66 | rec( |
| 179 | 67 | LastName := "Mayr", |
| 181 | 69 | IsAuthor := true, |
| 182 | 70 | IsMaintainer := true, |
| 183 | 71 | Email := "baernstein@gmail.com", |
| 184 | WWWHome := "http://www.algebra.uni-linz.ac.at/~stein/", | |
| 72 | WWWHome := "https://www.colorado.edu/math/peter-mayr", | |
| 185 | 73 | PostalAddress := Concatenation( [ |
| 186 | "Institut für Algebra\n", | |
| 187 | "Johannes Kepler Universität Linz\n", | |
| 188 | "4040 Linz\n", | |
| 189 | "Austria" ] ), | |
| 190 | Place := "Linz", | |
| 191 | Institution := "Johannes Kepler Universität Linz" | |
| 74 | "Department of Mathematics", | |
| 75 | "CU Boulder\n", | |
| 76 | "Boulder, Colorado", | |
| 77 | "USA" ] ), | |
| 78 | Place := "Boulder", | |
| 79 | Institution := "University of Colorado" | |
| 192 | 80 | ), |
| 193 | 81 | rec( |
| 194 | LastName := "Nöbauer", | |
| 82 | LastName := "Nöbauer", | |
| 195 | 83 | FirstNames := "Christof", |
| 196 | 84 | IsAuthor := true, |
| 197 | IsMaintainer := false, | |
| 198 | Email := "christof.noebauer@algebra.uni-linz.ac.at", | |
| 199 | WWWHome := "http://www.algebra.uni-linz.ac.at/", | |
| 200 | PostalAddress := Concatenation( [ | |
| 201 | "Institut für Algebra", | |
| 202 | "Johannes Kepler Universität Linz\n", | |
| 203 | "4040 Linz\n", | |
| 204 | "Austria" ] ), | |
| 205 | Place := "Linz", | |
| 206 | Institution := "Johannes Kepler Universität Linz" | |
| 207 | ) | |
| 208 | # provide such a record for each author and/or maintainer ... | |
| 85 | IsMaintainer := false | |
| 86 | ), | |
| 209 | 87 | |
| 210 | 88 | ], |
| 211 | 89 | |
| 212 | ## Status information. Currently the following cases are recognized: | |
| 213 | ## "accepted" for successfully refereed packages | |
| 214 | ## "deposited" for packages for which the GAP developers agreed | |
| 215 | ## to distribute them with the core GAP system | |
| 216 | ## "dev" for development versions of packages | |
| 217 | ## "other" for all other packages | |
| 218 | ## | |
| 219 | 90 | Status := "accepted", |
| 220 | # Status := "deposited", | |
| 221 | ||
| 222 | ## You must provide the next two entries if and only if the status is | |
| 223 | ## "accepted" because is was successfully refereed: | |
| 224 | # format: 'name (place)' | |
| 225 | # CommunicatedBy := "Mike Atkinson (St. Andrews)", | |
| 226 | 91 | CommunicatedBy := "Charles R.B. Wright (Univ. of Oregon)", |
| 227 | # format: mm/yyyy | |
| 228 | # AcceptDate := "08/1999", | |
| 229 | 92 | AcceptDate := "04/2003", |
| 230 | 93 | |
| 231 | ## For a central overview of all packages and a collection of all package | |
| 232 | ## archives it is necessary to have two files accessible which should be | |
| 233 | ## contained in each package: | |
| 234 | ## - A README file, containing a short abstract about the package | |
| 235 | ## content and installation instructions. | |
| 236 | ## - The PackageInfo.g file you are currently reading or editing! | |
| 237 | ## You must specify URLs for these two files, these allow to automate | |
| 238 | ## the updating of package information on the GAP Website, and inclusion | |
| 239 | ## and updating of the package in the GAP distribution. | |
| 240 | # | |
| 241 | README_URL := | |
| 242 | # "http://www.math.rwth-aachen.de/~Greg.Gamble/Example/README.example", | |
| 243 | "http://www.algebra.uni-linz.ac.at/Sonata/README.sonata", | |
| 244 | PackageInfoURL := | |
| 245 | # "http://www.math.rwth-aachen.de/~Greg.Gamble/Example/PackageInfo.g", | |
| 246 | "http://www.algebra.uni-linz.ac.at/Sonata/PackageInfo.g", | |
| 94 | PackageWWWHome := "https://gap-packages.github.io/sonata/", | |
| 95 | README_URL := Concatenation( ~.PackageWWWHome, "README" ), | |
| 96 | PackageInfoURL := Concatenation( ~.PackageWWWHome, "PackageInfo.g" ), | |
| 97 | SourceRepository := rec( | |
| 98 | Type := "git", | |
| 99 | URL := "https://github.com/gap-packages/sonata", | |
| 100 | ), | |
| 101 | IssueTrackerURL := Concatenation( ~.SourceRepository.URL, "/issues" ), | |
| 102 | ArchiveURL := Concatenation( ~.SourceRepository.URL, | |
| 103 | "/releases/download/v", ~.Version, | |
| 104 | "/sonata-", ~.Version ), | |
| 105 | ArchiveFormats := ".tar.gz", | |
| 247 | 106 | |
| 248 | 107 | ## Here you must provide a short abstract explaining the package content |
| 249 | 108 | ## in HTML format (used on the package overview Web page) and an URL |
| 251 | 110 | ## (not more than a few lines, less is ok): |
| 252 | 111 | ## Please, use '<span class="pkgname">GAP</span>' and |
| 253 | 112 | ## '<span class="pkgname">MyPKG</span>' for specifing package names. |
| 254 | ## | |
| 255 | # AbstractHTML := "This package provides a collection of functions for \ | |
| 256 | # computing the Smith normal form of integer matrices and some related \ | |
| 257 | # utilities.", | |
| 258 | 113 | AbstractHTML := |
| 259 | # "The <span class=\"pkgname\">Example</span> package, as its name suggests, \ | |
| 260 | # is an example of how to create a <span class=\"pkgname\">GAP</span> \ | |
| 261 | # package. It has little functionality except for being a package", | |
| 262 | 114 | "The <span class=\"pkgname\">SONATA</span> package provides methods for \ |
| 263 | 115 | the construction and analysis of finite nearrings.", |
| 264 | ||
| 265 | PackageWWWHome := | |
| 266 | # "http://www.math.rwth-aachen.de/~Greg.Gamble/Example", | |
| 267 | "http://www.algebra.uni-linz.ac.at/Sonata/", | |
| 268 | 116 | |
| 269 | ## Here is the information on the help books of the package, used for | |
| 270 | ## loading into GAP's online help and maybe for an online copy of the | |
| 271 | ## documentation on the GAP website. | |
| 272 | ## | |
| 273 | ## For the online help the following is needed: | |
| 274 | ## - the name of the book (.BookName) | |
| 275 | ## - a long title, shown by ?books (.LongTitle, optional) | |
| 276 | ## - the path to the manual.six file for this book (.SixFile) | |
| 277 | ## - a decision if the book should be (auto)loaded, probably 'true' | |
| 278 | ## (.Autoload) | |
| 279 | ## | |
| 280 | ## For an online version on a Web page further entries are needed, | |
| 281 | ## if possible, provide an HTML- and a PDF-version: | |
| 282 | ## - if there is an HTML-version the path to the start file, | |
| 283 | ## relative to the package home directory (.HTMLStart) | |
| 284 | ## - if there is a PDF-version the path to the .pdf-file, | |
| 285 | ## relative to the package home directory (.PDFFile) | |
| 286 | ## - give the paths to the files inside your package directory | |
| 287 | ## which are needed for the online manual (either as URL .Archive | |
| 288 | ## if you pack them into a separate archive, or as list | |
| 289 | ## .ArchiveURLSubset of directory and file names which should be | |
| 290 | ## copied from your package archive, given in .ArchiveURL above | |
| 291 | ## | |
| 292 | ## For links to other GAP or package manuals you can assume a relative | |
| 293 | ## position of the files as in a standard GAP installation. | |
| 294 | ## | |
| 295 | # in case of several help books give a list of such records here: | |
| 296 | 117 | PackageDoc := [ |
| 297 | 118 | rec( |
| 298 | # use same as in GAP | |
| 299 | 119 | BookName := "SONATA", |
| 300 | # format/extension can be one of .zoo, .tar.gz, .tar.bz2, -win.zip | |
| 301 | # Archive := | |
| 302 | # "http://www.math.rwth-aachen.de/~Greg.Gamble/Example/exampledoc-1.5.zoo", | |
| 303 | # "http://www.algebra.uni-linz.ac.at/Sonata/sonata-2.4/sonatadoc-2.4.tar.gz", | |
| 304 | # ArchiveURLSubset := ["doc", "htm"], | |
| 305 | 120 | ArchiveURLSubset := ["doc/ref","htm/ref"], |
| 306 | 121 | HTMLStart := "htm/ref/chapters.htm", |
| 307 | 122 | PDFFile := "doc/ref/manual.pdf", |
| 308 | # the path to the .six file used by GAP's help system | |
| 309 | 123 | SixFile := "doc/ref/manual.six", |
| 310 | # a longer title of the book, this together with the book name should | |
| 311 | # fit on a single text line (appears with the '?books' command in GAP) | |
| 312 | # LongTitle := "Elementary Divisors of Integer Matrices", | |
| 313 | 124 | LongTitle := "System of nearrings and their applications", |
| 314 | # Should this help book be autoloaded when GAP starts up? This should | |
| 315 | # usually be 'true', otherwise say 'false'. | |
| 316 | 125 | Autoload := true |
| 317 | ), | |
| 126 | ), | |
| 318 | 127 | rec( |
| 319 | # use same as in GAP | |
| 320 | 128 | BookName := "SONATA Tutorial", |
| 321 | # format/extension can be one of .zoo, .tar.gz, .tar.bz2, -win.zip | |
| 322 | # Archive := | |
| 323 | # "http://www.math.rwth-aachen.de/~Greg.Gamble/Example/exampledoc-1.5.zoo", | |
| 324 | # "http://www.algebra.uni-linz.ac.at/Sonata/sonata-2.4/sonatatut-2.4.tar.gz", | |
| 325 | # ArchiveURLSubset := ["doc", "htm"], | |
| 326 | 129 | ArchiveURLSubset := ["doc/tut","htm/tut"], |
| 327 | 130 | HTMLStart := "htm/tut/chapters.htm", |
| 328 | 131 | PDFFile := "doc/tut/manual.pdf", |
| 329 | # the path to the .six file used by GAP's help system | |
| 330 | 132 | SixFile := "doc/tut/manual.six", |
| 331 | # a longer title of the book, this together with the book name should | |
| 332 | # fit on a single text line (appears with the '?books' command in GAP) | |
| 333 | # LongTitle := "Elementary Divisors of Integer Matrices", | |
| 334 | LongTitle := "Eight easy pieces for SONATA: a SONATA tutorial", | |
| 335 | # Should this help book be autoloaded when GAP starts up? This should | |
| 336 | # usually be 'true', otherwise say 'false'. | |
| 133 | LongTitle := "Eight easy pieces for SONATA: a SONATA tutorial", | |
| 337 | 134 | Autoload := false |
| 338 | )], | |
| 135 | ), | |
| 136 | ], | |
| 339 | 137 | |
| 340 | 138 | |
| 341 | ## Are there restrictions on the operating system for this package? Or does | |
| 342 | ## the package need other packages to be available? | |
| 343 | 139 | Dependencies := rec( |
| 344 | # GAP version, use version strings for specifying exact versions, | |
| 345 | # prepend a '>=' for specifying a least version. | |
| 346 | GAP := ">=4.5", | |
| 347 | # list of pairs [package name, (least) version], package name is case | |
| 348 | # insensitive, least version denoted with '>=' prepended to version string. | |
| 349 | # without these, the package will not load | |
| 350 | # NeededOtherPackages := [["GAPDoc", ">= 0.99"]], | |
| 140 | GAP := ">=4.9", | |
| 351 | 141 | NeededOtherPackages := [], |
| 352 | # without these the package will issue a warning while loading | |
| 353 | # SuggestedOtherPackages := [], | |
| 354 | 142 | SuggestedOtherPackages := [["xgap",">=0"]], |
| 355 | # needed external conditions (programs, operating system, ...) provide | |
| 356 | # just strings as text or | |
| 357 | # pairs [text, URL] where URL provides further information | |
| 358 | # about that point. | |
| 359 | # (no automatic test will be done for this, do this in your | |
| 360 | # 'AvailabilityTest' function below) | |
| 361 | # ExternalConditions := [] | |
| 362 | 143 | ExternalConditions := [] |
| 363 | ||
| 364 | 144 | ), |
| 365 | 145 | |
| 366 | ## Provide a test function for the availability of this package. | |
| 367 | ## For packages which will not fully work, use 'Info(InfoWarning, 1, | |
| 368 | ## ".....")' statements. For packages containing nothing but GAP code, | |
| 369 | ## just say 'ReturnTrue' here. | |
| 370 | ## With the new package loading mechanism (GAP >=4.4) the availability | |
| 371 | ## tests of other packages, as given under .Dependencies above, will be | |
| 372 | ## done automatically and need not be included in this function. | |
| 373 | #AvailabilityTest := ReturnTrue, | |
| 374 | AvailabilityTest := function() | |
| 375 | # local path,file; | |
| 376 | # # test for existence of the compiled binary | |
| 377 | # path:=DirectoriesPackagePrograms("example"); | |
| 378 | # file:=Filename(path,"hello"); | |
| 379 | # if file=fail then | |
| 380 | # Info(InfoWarning,1, | |
| 381 | # "Package ``Example'': The program `hello' is not compiled"); | |
| 382 | # Info(InfoWarning,1, | |
| 383 | # "`HelloWorld()' is thus unavailable"); | |
| 384 | # Info(InfoWarning,1, | |
| 385 | # "See the installation instructions; ", | |
| 386 | # "type: ?Installing the Example package"); | |
| 387 | # fi; | |
| 388 | # # if the hello binary was vital to the package we would return | |
| 389 | # # the following ... | |
| 390 | # #return file<>fail; | |
| 391 | # # since the hello binary is not vital we return ... | |
| 392 | # return true; | |
| 393 | # end, | |
| 394 | return true; | |
| 395 | end, | |
| 146 | AvailabilityTest := ReturnTrue, | |
| 396 | 147 | |
| 397 | 148 | ## The LoadPackage mechanism can produce a default banner from the info |
| 398 | 149 | ## in this file. If you are not happy with it, you can provide a string |
| 399 | 150 | ## here that is used as a banner. GAP decides when the banner is shown and |
| 400 | 151 | ## when it is not shown. *optional* (note the ~-syntax in this example) |
| 401 | 152 | BannerString := Concatenation( |
| 402 | # "----------------------------------------------------------------\n", | |
| 403 | # "Loading Example ", ~.Version, "\n", | |
| 404 | # "by ", ~.Persons[1].FirstNames, " ", ~.Persons[1].LastName, | |
| 405 | # " (", ~.Persons[1].WWWHome, ")\n", | |
| 406 | # " ", ~.Persons[2].FirstNames, " ", ~.Persons[2].LastName, | |
| 407 | # " (", ~.Persons[2].WWWHome, ")\n", | |
| 408 | # "For help, type: ?Example package \n", | |
| 409 | # "----------------------------------------------------------------\n" ), | |
| 410 | 153 | "\n ___________________________________________________________________________", |
| 411 | 154 | "\n / ___", |
| 412 | "\n|| / \\ /\\ Version", ~.Version, | |
| 155 | "\n|| / \\ /\\ Version ", ~.Version, | |
| 413 | 156 | "\n|| || || |\\ | / \\ /\\ Erhard Aichinger", |
| 414 | 157 | "\n \\___ || || |\\\\ | /____\\_____________/__\\ Franz Binder", |
| 415 | 158 | "\n \\ || || | \\\\ | / \\ || / \\ Juergen Ecker", |
| 419 | 162 | "\n System Of Nearrings And Their Applications\n", |
| 420 | 163 | " Info: ", ~.PackageWWWHome, "\n\n" ), |
| 421 | 164 | |
| 422 | ## Suggest here if the package should be *automatically loaded* when GAP is | |
| 423 | ## started. This should usually be 'false'. Say 'true' only if your package | |
| 424 | ## provides some improvements of the GAP library which are likely to enhance | |
| 425 | ## the overall system performance for many users. | |
| 426 | Autoload := false, | |
| 427 | 165 | |
| 428 | ## *Optional*, but recommended: path relative to package root to a file which | |
| 429 | ## contains as many tests of the package functionality as sensible. | |
| 430 | #TestFile := "tst/testall.g", | |
| 166 | TestFile := "tst/testall.g", | |
| 431 | 167 | |
| 432 | ## *Optional*: Here you can list some keyword related to the topic | |
| 433 | ## of the package. | |
| 434 | # Keywords := ["Smith normal form", "p-adic", "rational matrix inversion"] | |
| 435 | Keywords := ["near ring", "endomorphism", "Frobenius group", "fixed point free automorphism"] | |
| 168 | Keywords := ["near ring", "endomorphism", "Frobenius group", "fixed point free automorphism"], | |
| 436 | 169 | |
| 437 | 170 | )); |
| 438 | 171 | |
| 0 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ | |
| 1 | + + | |
| 2 | + Copyright (C) 2012 Erhard Aichinger, Franz Binder + | |
| 3 | + Jürgen Ecker, Peter Mayr, Christof Nöbauer + | |
| 4 | + + | |
| 5 | + This file is part of Sonata. + | |
| 6 | + + | |
| 7 | + Sonata is free software: you can redistribute it and/or modify + | |
| 8 | + it under the terms of the GNU General Public License as published by + | |
| 9 | + the Free Software Foundation, either version 2 of the License, or + | |
| 10 | + (at your option) any later version. + | |
| 11 | + + | |
| 12 | + Sonata is distributed in the hope that it will be useful, + | |
| 13 | + but WITHOUT ANY WARRANTY; without even the implied warranty of + | |
| 14 | + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + | |
| 15 | + GNU General Public License for more details. + | |
| 16 | + + | |
| 17 | + You should have received a copy of the GNU General Public License + | |
| 18 | + along with Sonata. If not, see <http://www.gnu.org/licenses/>. + | |
| 19 | + + | |
| 20 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ | |
| 21 | ||
| 22 | ||
| 23 | ||
| 24 | README file for the GAP4 package SONATA | |
| 25 | ||
| 26 | ||
| 27 | ||
| 28 | To install SONATA, unpack the archive inside the `pkg' subdirectory of | |
| 29 | your GAP 4 installation. It creates a subdirectory called `sonata'. | |
| 30 | ||
| 31 | Then start GAP and load SONATA with the command | |
| 32 | ||
| 33 | LoadPackage("sonata"); | |
| 34 | ||
| 35 | In addition to the standard GAP help, we have produced a tutorial for | |
| 36 | SONATA, which can be found in the subdirectory doc/tut/ of the sonata | |
| 37 | package. | |
| 38 | ||
| 39 | E-mail us if there are any questions, remarks, suggestions. Also, we | |
| 40 | would like to hear about applications of this package. | |
| 41 | ||
| 42 | Erhard Aichinger | |
| 43 | Franz Binder | |
| 44 | Jürgen Ecker | |
| 45 | Peter Mayr | |
| 46 | Christof Nöbauer | |
| 47 | ||
| 48 | email: sonata@algebra.uni-linz.ac.at | |
| 49 | ||
| 50 | ||
| 51 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 52 | ||
| 53 | Main changes from SONATA 2.6 to SONATA 2.8 | |
| 54 | ------------------------------------------ | |
| 55 | ||
| 56 | (1) Corrected bugs in Is1AffineComplete and IsDistributiveNearring |
| 0 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ | |
| 1 | + + | |
| 2 | + Copyright (C) 2012 Erhard Aichinger, Franz Binder + | |
| 3 | + Jürgen Ecker, Peter Mayr, Christof Nöbauer + | |
| 4 | + + | |
| 5 | + This file is part of Sonata. + | |
| 6 | + + | |
| 7 | + Sonata is free software: you can redistribute it and/or modify + | |
| 8 | + it under the terms of the GNU General Public License as published by + | |
| 9 | + the Free Software Foundation, either version 2 of the License, or + | |
| 10 | + (at your option) any later version. + | |
| 11 | + + | |
| 12 | + Sonata is distributed in the hope that it will be useful, + | |
| 13 | + but WITHOUT ANY WARRANTY; without even the implied warranty of + | |
| 14 | + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + | |
| 15 | + GNU General Public License for more details. + | |
| 16 | + + | |
| 17 | + You should have received a copy of the GNU General Public License + | |
| 18 | + along with Sonata. If not, see <http://www.gnu.org/licenses/>. + | |
| 19 | + + | |
| 20 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ | |
| 21 | ||
| 22 | ||
| 23 | ||
| 24 | README file for the GAP4 package SONATA | |
| 25 | ||
| 26 | ||
| 27 | ||
| 28 | To install SONATA, unpack the archive inside the `pkg' subdirectory of | |
| 29 | your GAP 4 installation. It creates a subdirectory called `sonata'. | |
| 30 | ||
| 31 | Then start GAP and load SONATA with the command | |
| 32 | ||
| 33 | LoadPackage("sonata"); | |
| 34 | ||
| 35 | In addition to the standard GAP help, we have produced a tutorial for | |
| 36 | SONATA, which can be found in the subdirectory doc/tut/ of the sonata | |
| 37 | package. | |
| 38 | ||
| 39 | E-mail us if there are any questions, remarks, suggestions. Also, we | |
| 40 | would like to hear about applications of this package. | |
| 41 | ||
| 42 | Erhard Aichinger | |
| 43 | Franz Binder | |
| 44 | Jürgen Ecker | |
| 45 | Peter Mayr | |
| 46 | Christof Nöbauer | |
| 47 | ||
| 48 | email: sonata@algebra.uni-linz.ac.at | |
| 49 | ||
| 50 | ||
| 51 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 52 | ||
| 53 | Main changes from SONATA 2.6 to SONATA 2.8 | |
| 54 | ------------------------------------------ | |
| 55 | ||
| 56 | (1) Corrected bugs in Is1AffineComplete and IsDistributiveNearring |
| 0 | #!/usr/bin/perl -w | |
| 1 | # | |
| 2 | # Script to convert GAP manual TeX files to HTML | |
| 3 | # Usage: | |
| 4 | # convert.pl [-csti] [-f <frontpage>] [-n <pkgname>] <doc-dir> [<html-dir>] | |
| 5 | # | |
| 6 | # Requirements: Perl (might need to edit the first line of this file) | |
| 7 | # TtH is not strictlty necessary but very desirable to treat | |
| 8 | # formulas. | |
| 9 | # | |
| 10 | # Caveats: | |
| 11 | # | |
| 12 | # 1. This script assumes that the .toc, .lab and .bbl files are up-to-date | |
| 13 | # with the .tex files and will almost certainly fail horribly if they | |
| 14 | # are not. | |
| 15 | # | |
| 16 | # 2. The output files are CxxxSxxx.htm, (not .html) plus chapters.htm, | |
| 17 | # theindex.htm and biblio.htm, except when called with the -c option | |
| 18 | # (in which case, there are CHAPxxx.htm files instead of CxxxSxxx.htm). | |
| 19 | # A (front page) file index.htm is assumed, but not created. | |
| 20 | # Not all servers will serve .htm files as HTML without adjustments. | |
| 21 | # | |
| 22 | # 3. The script assumes that the .tex files comply with GAP conventions, | |
| 23 | # including unwritten ones. It tries to follow the behaviour of TeX | |
| 24 | # assuming those conventions. The on-line browser attempts to provide | |
| 25 | # an ASCII equivalent. See BUGS. | |
| 26 | # | |
| 27 | # 4. The hierarchy of the HTML manuals assumed is of the following form: | |
| 28 | # | |
| 29 | # <GAPDIR>/ | |
| 30 | # doc/ | |
| 31 | # <main> | |
| 32 | # pkg/ | |
| 33 | # <pkg>/ | |
| 34 | # htm | |
| 35 | # | |
| 36 | # for each main manual <main> (in: ref, tut, changes) and each | |
| 37 | # package <pkg>. To make inter-linking between manuals work, | |
| 38 | # one should generally use the -c option for everything, (or not use | |
| 39 | # it for everything). Linking to package manuals from the main | |
| 40 | # manual can only be expected to work if the package manuals | |
| 41 | # are created using this converter. | |
| 42 | # | |
| 43 | # 5. Only the manual.lab files for books that are referenced via the | |
| 44 | # \UseReferences and \UseGapDocReferences commands in the manual.tex | |
| 45 | # file of the book being converted (and the book's own manual.lab | |
| 46 | # file, of course) are read. Make sure all the \UseReferences and | |
| 47 | # \UseGapDocReferences commands needed are present! (The TeX-produced | |
| 48 | # manuals will be missing lots of cross-references also, if some are | |
| 49 | # missing.) You will get `Bad link' messages if you have some missing. | |
| 50 | # | |
| 51 | # Options: | |
| 52 | # | |
| 53 | # -c file-per-chapter mode: Generates one HTML file CHAPxxx.htm | |
| 54 | # for each chapter; sections are level 2 headings and anchors | |
| 55 | # CHAPxxx.htm#SECTxxx. | |
| 56 | # This is intended for local browsing, especially under MS-DOS. | |
| 57 | # It may be used with the -n (package) option. | |
| 58 | # | |
| 59 | # -f <frontpage> | |
| 60 | # Adds a "Top" link to link <frontpage> to each manual page, | |
| 61 | # only available if -n option is also used. | |
| 62 | # | |
| 63 | # -s silent running: Conversational messages are suppressed. | |
| 64 | # | |
| 65 | # -n <pkgname> | |
| 66 | # We are not building the main manual but the one for the | |
| 67 | # package <pkgname>. To get cross references to the main library | |
| 68 | # right, it assumes that the package is in the right place. | |
| 69 | # The -c option may be used with this option. | |
| 70 | # | |
| 71 | # -i index: Only one index file is produced. | |
| 72 | # | |
| 73 | # -t tex-math: Runs `tth' (which must be installed on the local system) | |
| 74 | # to produce better HTML code for formulae. (It would be possible to | |
| 75 | # replace tth by another conversion, for example TeXexplorer, but | |
| 76 | # (at least) the line calling `tth' would need to be modified.) | |
| 77 | ||
| 78 | # -u Like -t, but uses `tth -u2' to produce unicode. | |
| 79 | # | |
| 80 | # <doc-dir> The directory where all the needed .tex, .toc, .lab and .bbl | |
| 81 | # files are located. | |
| 82 | # | |
| 83 | # <html-dir> The directory (which should already exist) in which to put | |
| 84 | # the generated .htm files. Defaults to the current directory, | |
| 85 | # if omitted. | |
| 86 | # | |
| 87 | # Example usage: | |
| 88 | # convert.pl -n mypkg doc htm # in directory .../pkg/mypkg | |
| 89 | # convert.pl -t -n mypkg doc htm # ditto previous + use tth for maths | |
| 90 | # convert.pl -t -n mypkg -c doc htm # ditto previous + 1 file per chapter | |
| 91 | # convert.pl -t -c ../ref ref # (for Ref manual) in dir .../doc/htm | |
| 92 | # | |
| 93 | # FEATURES (and intended departures from the TeX behaviour) | |
| 94 | # . Now interprets 2nd argument of an \atindex command if it is | |
| 95 | # of form @... and ignores the first argument, or otherwise it | |
| 96 | # interprets the first argument. Interprets ! as a comma and | |
| 97 | # indices output have no sub-headers. | |
| 98 | # . The @... component of \> commands is ignored. The assumption | |
| 99 | # is that for: \>`...'{...}@{...} the @{...} component is just | |
| 100 | # the {...} with font changes. | |
| 101 | # . In a \beginitems ... \enditems environment everything is indented | |
| 102 | # except for the item headers, rather than just the paragraph | |
| 103 | # following the item header. | |
| 104 | # . By default, the \beginlist ... \endlist environment is interpreted | |
| 105 | # as a compact description list. By adding %unordered or %ordered... | |
| 106 | # markup it will be interpreted as either an unordered or ordered | |
| 107 | # list respectively (see gapmacro documentation for details). | |
| 108 | # . There are spacing differences e.g. \begintt ... \endtt etc. | |
| 109 | # environments are not indented. | |
| 110 | # . Supports all accents of TeX, in probably the best way currently | |
| 111 | # possible with HTML. | |
| 112 | # . Treats PseudoInput chapters in the `same' way as Input chapters. | |
| 113 | # . With -t switch announces the version of TtH used. | |
| 114 | # . Now supports %display{nontex}, %display{nontext} and | |
| 115 | # %display{nonhtml} variants of %display environment. | |
| 116 | # . References to subsections are now interpreted as one would expect. | |
| 117 | # | |
| 118 | # BUGS (and known departures from the TeX behaviour) | |
| 119 | # . $a.b$ is only interpreted correctly in -t mode. | |
| 120 | # . The citation keys that appear are the .bib file keys rather | |
| 121 | # than the keys BibTeX constructs with the `alpha' bib-style. | |
| 122 | # | |
| 123 | # TODO | |
| 124 | # . Refine macro_replace subroutine so it can also be used to purge | |
| 125 | # 2nd arg of \atindex macros. | |
| 126 | # . For -t mode, scan for \def commands in manual.tex and write | |
| 127 | # to TTHIN (tthmacros.tex). Should we only look for a block | |
| 128 | # demarcated by %mathsmacros ... %endmathsmacros ? | |
| 129 | # These \def commands are only intended for such font | |
| 130 | # changing commands as: \def\B{{\cal B}} (`tth' provides a | |
| 131 | # script-type font). | |
| 132 | # . Provide a table environment, if/when a \begintable ... | |
| 133 | # \endtable environment is added to gapmacro.tex. | |
| 134 | # | |
| 135 | ############################################################################# | |
| 136 | ||
| 137 | # Check PERL version | |
| 138 | # | |
| 139 | $] > 5 or die "Needs perl 5"; | |
| 140 | ||
| 141 | use Getopt::Std; | |
| 142 | ||
| 143 | ||
| 144 | # | |
| 145 | # Global variables | |
| 146 | # | |
| 147 | # $dir -- the full pathname of the input directory, including a trailing / | |
| 148 | # $odir -- the full pathname of the output directory, including a trailing / | |
| 149 | # $opt_c and $opt_s set by getopts() | |
| 150 | # @chapters -- the chapters data structure | |
| 151 | # IN -- the current input file (outputfiles are handled by select) | |
| 152 | # $footer -- the trailer put on every page | |
| 153 | # $indexcount -- used within chapters to number the index anchors | |
| 154 | # $lastnumchap -- number of last numerically numbered chapter | |
| 155 | # | |
| 156 | ||
| 157 | ||
| 158 | # These match chapter and section lines in a .toc file | |
| 159 | # | |
| 160 | ||
| 161 | $chapexp = '\\\\chapcontents\s+\{((?:\d+|[A-Z]))\}\s*\{(.+)\}\s*\{\d+\}'; | |
| 162 | $secexp = '\\\\seccontents\s+\{((?:\d+|[A-Z]))\.(\d+)\}\s*\{(.+)\}\s*\{\d+\}'; | |
| 163 | #$ignoreexp = '\\\\tocstrut|\\\\appno|\\\\seccontents\s+\{\d+\}'; | |
| 164 | $lastnumchap = 0; | |
| 165 | ||
| 166 | # Variable that is set to 2 inside a nest of \itemitem s of a | |
| 167 | # \beginlist ... \endlist environment | |
| 168 | # | |
| 169 | ||
| 170 | $listdepth = 0; | |
| 171 | ||
| 172 | # This is augmented each time a line: \Package{...} is read in a manual.tex | |
| 173 | # file, so that macro_replace knows to set a {\...} macro in sans-serif. | |
| 174 | # | |
| 175 | ||
| 176 | $sharepkg = ""; | |
| 177 | ||
| 178 | # The books converted to HTML with this converter | |
| 179 | # The values set are: 0 or 1 according to whether or not -c was used. | |
| 180 | # | |
| 181 | ||
| 182 | %convertbooks = (); | |
| 183 | ||
| 184 | # This is added to when scanning GAPDoc manuals. | |
| 185 | # | |
| 186 | ||
| 187 | %gapdocbooks = (); | |
| 188 | ||
| 189 | # Types of href label are: | |
| 190 | # 0 (non -c books) : C<MMM>S<NNN>.htm | |
| 191 | # 1 (-c books) : CHAP<MMM>.htm#SECT<NNN> | |
| 192 | # 2 (== $gapdoc) : chap<M>.html#<gapdoc-id> | |
| 193 | # | |
| 194 | # It would be nice to support subsections properly like GapDoc, | |
| 195 | # but this involves creating a subsection data-structure modelled | |
| 196 | # on section, which is a mite non-trivial (maybe ... if I find time). | |
| 197 | # For now in-text references go to the beginning of the chapter. | |
| 198 | # | |
| 199 | # BH: it might be easier to use tags based on the name of the function | |
| 200 | ||
| 201 | $gapdoc = 2; | |
| 202 | ||
| 203 | # sansserif: | |
| 204 | # | |
| 205 | # Used mainly to set GAP in sans serif font. Inside <title> ... </title> | |
| 206 | # there should *not* be any tags, since they are not translated there by | |
| 207 | # web browsers, and hence sansserif should *not* be applied to anything | |
| 208 | # that ends up in the <title> ... </title> field, but *is* quite appropriate | |
| 209 | # for the header in the <h1> ... </h1> field at the top of the body of an | |
| 210 | # HTML file and anywhere else within the body of an HTML file. | |
| 211 | # | |
| 212 | sub sansserif { | |
| 213 | my ($name) = @_; | |
| 214 | return "<font face=\"Gill Sans,Helvetica,Arial\">$name</font>"; | |
| 215 | } | |
| 216 | ||
| 217 | # booktitle_body: | |
| 218 | # | |
| 219 | # This is for generating the title of a document that goes in the | |
| 220 | # <h1> ... </h1> field at the top of the body, as opposed to the title | |
| 221 | # that goes in the <title> ... </title> field which should be unembellished. | |
| 222 | # | |
| 223 | sub booktitle_body { | |
| 224 | my ($bktitle, @prog_or_pkg) = @_; | |
| 225 | foreach $prog_or_pkg (@prog_or_pkg) { | |
| 226 | $newstring = sansserif $prog_or_pkg; | |
| 227 | $bktitle =~ s/$prog_or_pkg/$newstring/; | |
| 228 | } | |
| 229 | return $bktitle; | |
| 230 | } | |
| 231 | ||
| 232 | # | |
| 233 | # used to standardize section names for use as hash indices. | |
| 234 | # | |
| 235 | ||
| 236 | sub canonize { | |
| 237 | my ($key) = @_; | |
| 238 | $key =~ tr/A-Z/a-z/; | |
| 239 | $key =~ s/\s//g; | |
| 240 | $key =~ s/\\//g; | |
| 241 | $key; | |
| 242 | } | |
| 243 | sub kanonize { | |
| 244 | my ($key) = @_; | |
| 245 | $key =~ s/\\ / /g; | |
| 246 | $key =~ s/!/ /g; | |
| 247 | $key; | |
| 248 | } | |
| 249 | ||
| 250 | sub def_section_by_name { | |
| 251 | my ($sec, $chapno, $secno, $ssecno, $name) = @_; | |
| 252 | my $secname = canonize $1; | |
| 253 | if (defined $sections_by_name{$secname}) { | |
| 254 | if (($sections_by_name{$secname}->{chapnum} ne $chapno) || | |
| 255 | ($sections_by_name{$secname}->{secnum} ne $secno) || | |
| 256 | ($sections_by_name{$secname}->{ssecnum} ne $ssecno)) { | |
| 257 | print STDERR "Section: \"$secname\" already defined as: ", | |
| 258 | "$sections_by_name{$secname}->{chapnum}.", | |
| 259 | "$sections_by_name{$secname}->{secnum}.", | |
| 260 | "$sections_by_name{$secname}->{ssecnum}\n"; | |
| 261 | print STDERR "Now being redefined as: $chapno.$secno.$ssecno\n"; | |
| 262 | $redefined_secname{$secname} = 1; | |
| 263 | } else { | |
| 264 | return; | |
| 265 | } | |
| 266 | } | |
| 267 | $sections_by_name{$secname} | |
| 268 | = {chapnum => $chapno, | |
| 269 | secnum => $secno, | |
| 270 | ssecnum => $ssecno, | |
| 271 | name => $name}; | |
| 272 | # print STDERR "Defined section \"$secname\": $chapno.$secno.$ssecno $name\n"; | |
| 273 | } | |
| 274 | ||
| 275 | sub tonum { # Needed since chanu may be A,B,... for appendices | |
| 276 | my ($chanu) = @_; | |
| 277 | return $chanu =~ /\d+/ ? $chanu : $lastnumchap + ord($chanu) - ord('A') + 1; | |
| 278 | } | |
| 279 | ||
| 280 | # getchaps: | |
| 281 | # | |
| 282 | # Scan the .tex and .toc files to get chapter names and numbers, | |
| 283 | # section names and numbers and associated filenames. | |
| 284 | # Loads up chapters and sections_by_name. | |
| 285 | # | |
| 286 | ||
| 287 | sub getchaps { | |
| 288 | open( TOC, "<${dir}manual.toc" ) | |
| 289 | || die "Can't open ${dir}manual.toc.\n You can " . | |
| 290 | "create the .toc file by doing: tex manual (at least once).\n"; | |
| 291 | my ($chap,$sec,$chapno,$chap_as_sec,$chapnam,$chanu); | |
| 292 | while (<TOC>) { | |
| 293 | if ( /$chapexp/o ) { | |
| 294 | $chapnam = $2; | |
| 295 | $chanu = $1; | |
| 296 | $lastnumchap = $chanu if ( $chanu =~ /\d+/ ); | |
| 297 | ||
| 298 | # remove `(preliminary)' part that messes everything up | |
| 299 | $chapnam =~ s/ \(preliminary\)//g; | |
| 300 | ||
| 301 | $chap = {name => $chapnam, | |
| 302 | number => $chanu}; | |
| 303 | $chap_as_sec = {name => $chapnam, | |
| 304 | chapnum => $chanu, | |
| 305 | secnum => 0, | |
| 306 | chapter => $chap}; | |
| 307 | $chap->{sections}[0] = $chap_as_sec; | |
| 308 | defined ($chapters[tonum $chanu]) && die "chapter number repeated"; | |
| 309 | $chapters[tonum $chanu] = $chap; | |
| 310 | } elsif ( /$secexp/o ) { | |
| 311 | defined ($chapters[tonum $1]) | |
| 312 | || die "section $2:$3 in unknown chapter $1"; | |
| 313 | defined ($chapters[tonum $1]{sections}[$2]) | |
| 314 | && die "section number repeated"; | |
| 315 | $sec = {name => $3, | |
| 316 | secnum => $2, | |
| 317 | chapnum => $1, | |
| 318 | chapter => $chapters[tonum $1]}; | |
| 319 | $chapters[tonum $1]{sections}[$2] = $sec; | |
| 320 | # this would produce warnings from empty chapters. Thus ignore. | |
| 321 | # } elsif ( $_ !~ /$ignoreexp/o ) { | |
| 322 | # print STDERR "Bad line: $_"; | |
| 323 | } | |
| 324 | } | |
| 325 | close TOC; | |
| 326 | open (TEX, "<${dir}manual.tex") || die "Can't open ${dir}manual.tex"; | |
| 327 | $chapno = 0; | |
| 328 | while (<TEX>) { | |
| 329 | if ( /^[^%]*\\(|Pseudo)Input\{([^}]+)\}(\{([^}]+)\}\{([^}]+)\})?/ ) { | |
| 330 | if (not -f "$dir$2.tex" or not -r "$dir$2.tex") { | |
| 331 | print STDERR "Chapter file $2.tex does not exist in $dir\n"; | |
| 332 | } | |
| 333 | if ($1 eq "") { | |
| 334 | $chapters[++$chapno]{file} = $2; | |
| 335 | } else { | |
| 336 | $chapnam = $5; | |
| 337 | $chanu = ++$chapno; | |
| 338 | $lastnumchap = $chanu; | |
| 339 | ||
| 340 | $chap = {name => $chapnam, | |
| 341 | number => $chanu}; | |
| 342 | $chap_as_sec = {name => $chapnam, | |
| 343 | chapnum => $chanu, | |
| 344 | secnum => 0, | |
| 345 | ssecnum => 0, | |
| 346 | chapter => $chap}; | |
| 347 | if ($4 ne $5) { | |
| 348 | def_section_by_name("$book:$chapnam", $chanu, 0, 0, canonize $chapnam); | |
| 349 | add_to_index(htm_fname($opt_c,$chanu,0, 0, ""), | |
| 350 | $4, $chap_as_sec, 0); | |
| 351 | } | |
| 352 | ||
| 353 | $chap->{sections}[0] = $chap_as_sec; | |
| 354 | defined($chapters[$chanu]) && die "chapter number repeated"; | |
| 355 | $chapters[$chanu] = $chap; | |
| 356 | $chapters[$chanu]{file} = $2; | |
| 357 | } | |
| 358 | } | |
| 359 | } | |
| 360 | close TEX; | |
| 361 | } | |
| 362 | ||
| 363 | sub getlabs { | |
| 364 | my ($bkdir) = @_; | |
| 365 | ||
| 366 | open (LAB, "<${bkdir}manual.lab") || print "Can't open ${bkdir}manual.lab"; | |
| 367 | while (<LAB>) { | |
| 368 | if ( /\\setcitlab/ ) { | |
| 369 | next; # We don't get the bibliography labels from here | |
| 370 | } elsif ( /\\GAPDocLabFile\s*\{([^}]+)\}/ ) { | |
| 371 | $gapdocbooks{$1} = 1; | |
| 372 | print STDERR "GapDoc books: ", keys(%gapdocbooks), "\n"; | |
| 373 | } elsif (/\\makelabel\s*\{([^}]+)\}\s*\{(\w+)(\.(\d+))?(\.(\d+))?\}\{([^}]+)\}/) { | |
| 374 | def_section_by_name($1, $2, (defined($3) ? $4 : 0), | |
| 375 | (defined($5) ? $6 : 0), $7); | |
| 376 | } elsif (/\\makelabel\s*\{([^}]+)\}\s*\{(\w+)(\.(\d+))?(\.(\d+))?\}/) { | |
| 377 | def_section_by_name($1, $2, (defined($3) ? $4 : 0), | |
| 378 | (defined($5) ? $6 : 0), ""); | |
| 379 | } else { | |
| 380 | chomp; | |
| 381 | print STDERR "Ignored line: $_\n... in ${bkdir}manual.lab\n"; | |
| 382 | } | |
| 383 | } | |
| 384 | close LAB; | |
| 385 | } | |
| 386 | ||
| 387 | # | |
| 388 | # Mainly diagnostic, prints the chapters data structure. Also | |
| 389 | # checks that each section has the correct back reference to its | |
| 390 | # chapter | |
| 391 | # | |
| 392 | ||
| 393 | sub printchaps { | |
| 394 | my @chapters = @_; | |
| 395 | CHAP: foreach $chapter (@chapters) { | |
| 396 | next CHAP unless (defined ($chapter)); | |
| 397 | print "Chapter $chapter->{number} $chapter->{name} $chapter->{file}\n"; | |
| 398 | SECT: foreach $section (@{$chapter->{sections}}) { | |
| 399 | next SECT unless defined ($section); | |
| 400 | print " Section $section->{chapnum}.$section->{secnum} $section->{name}\n"; | |
| 401 | if ($section->{chapter} ne $chapter ) { | |
| 402 | print " loop problem\n"; | |
| 403 | } | |
| 404 | } | |
| 405 | ||
| 406 | } | |
| 407 | } | |
| 408 | ||
| 409 | # Printed at the bottom of every page. | |
| 410 | $footer = "<P>\n" . sansserif( "GAP 4 manual<br>" . `date +"%B %Y"` ) . | |
| 411 | "</body></html>"; | |
| 412 | ||
| 413 | # Section label ... this is the bit that goes after a # in an HREF link | |
| 414 | # or is assigned to the value of NAME in an anchor. | |
| 415 | # | |
| 416 | sub sec_label { | |
| 417 | my ($c_s_gapdoc,$cnum,$snum,$ssnum) = @_; | |
| 418 | ||
| 419 | if ($c_s_gapdoc == $gapdoc) { | |
| 420 | return "s${snum}ss${ssnum}"; | |
| 421 | } | |
| 422 | ||
| 423 | $snum = "0" x (3 - length $snum) . $snum; | |
| 424 | if ($c_s_gapdoc) { | |
| 425 | if ($snum eq "000") { | |
| 426 | return ""; | |
| 427 | } elsif ($ssnum) { | |
| 428 | return "SSEC${snum}.$ssnum"; | |
| 429 | } else { | |
| 430 | return "SECT${snum}"; | |
| 431 | } | |
| 432 | } else { | |
| 433 | return ($ssnum) ? "SSEC$ssnum" : ""; | |
| 434 | } | |
| 435 | } | |
| 436 | ||
| 437 | # The HREFs of subsections, sections and chapter files are determined by | |
| 438 | # this routine directly if the chapter, section, subsection numbers are known. | |
| 439 | sub htm_fname { | |
| 440 | my ($c_s_gapdoc,$cnum,$snum,$ssnum,$name) = @_; | |
| 441 | # print STDERR "making htm_fname from $cnum.$snum.$ssnum $name\n"; | |
| 442 | ||
| 443 | my $seclabel = "$name"; | |
| 444 | ||
| 445 | $seclabel = sec_label($c_s_gapdoc,$cnum,$snum,$ssnum) if ($seclabel eq ""); | |
| 446 | $seclabel = "#$seclabel" if ($seclabel ne ""); | |
| 447 | # print STDERR "made $seclabel\n"; | |
| 448 | ||
| 449 | if ($c_s_gapdoc == $gapdoc) { | |
| 450 | return "chap${cnum}.html$seclabel"; | |
| 451 | } | |
| 452 | ||
| 453 | $cnum = "0" x (3 - length $cnum) . $cnum; | |
| 454 | $snum = "0" x (3 - length $snum) . $snum; | |
| 455 | return ($c_s_gapdoc) ? "CHAP${cnum}.htm$seclabel" | |
| 456 | : "C${cnum}S$snum.htm$seclabel"; | |
| 457 | } | |
| 458 | ||
| 459 | # Returns the value that $opt_c must have had when the book $book | |
| 460 | # was compiled with this converter. | |
| 461 | sub hreftype { | |
| 462 | my ($book, $bdir) = @_; | |
| 463 | if ( !(exists $convertbooks{$book}) ) { | |
| 464 | my @ls = `ls ${odir}$bdir`; | |
| 465 | $convertbooks{$book} | |
| 466 | = (grep { m/^CHAP...[.]htm$/ } @ls) ? | |
| 467 | 1 : # .htm files have shape CHAP<MMM>.htm | |
| 468 | (grep { m/^CHAP...[.]htm$/ } @ls) ? | |
| 469 | 0 : # .htm files have shape C<MMM>S<NNN>.htm | |
| 470 | (grep { m/^chap...[.]html$/ } @ls) ? | |
| 471 | 2 : # .html files have shape chapM.html | |
| 472 | $opt_c; # can't determine the shape ... don't exist | |
| 473 | # yet ... we assume the shape of the current | |
| 474 | # manual being compiled. | |
| 475 | } | |
| 476 | return $convertbooks{$book}; | |
| 477 | } | |
| 478 | ||
| 479 | # The names of the section and chapter files are determined by this routine | |
| 480 | # when one has to determine the chapter and section number indirectly. | |
| 481 | sub name2fn { | |
| 482 | my ($name,$ischap) = @_; | |
| 483 | my $bdir = ""; | |
| 484 | my $c_s_gapdoc = $opt_c; | |
| 485 | ||
| 486 | # : indicates a cross-volume reference | |
| 487 | my $canon_name = canonize $name; | |
| 488 | #print STDERR "canon_name = $canon_name\n"; | |
| 489 | if ( $canon_name =~ /^(ref|tut|changes):/ ) { | |
| 490 | if ($mainman==1) { | |
| 491 | $bdir = "../$1/"; | |
| 492 | } else { | |
| 493 | $bdir = "../../../doc/$1/"; | |
| 494 | } | |
| 495 | $c_s_gapdoc = hreftype($1, $bdir); | |
| 496 | } elsif ($canon_name =~ /^([a-zA-Z_0-9]*):/ ) { | |
| 497 | # presumably a package name | |
| 498 | #print STDERR "package name = $1\n"; | |
| 499 | if ($mainman==1) { | |
| 500 | if (exists $gapdocbooks{$1}) { # a main manual referring | |
| 501 | $bdir = "../../../pkg/$1/doc/"; # to a GapDoc-produced manual | |
| 502 | $c_s_gapdoc = $gapdoc; | |
| 503 | } else { | |
| 504 | $bdir = "../../../pkg/$1/htm/"; | |
| 505 | $c_s_gapdoc = hreftype($1, $bdir); | |
| 506 | } | |
| 507 | } elsif (exists $gapdocbooks{$1}) { # a package manual referring | |
| 508 | $bdir = "../../$1/doc/"; # to a GapDoc-produced manual | |
| 509 | $c_s_gapdoc = $gapdoc; | |
| 510 | } else { | |
| 511 | $bdir = "../../$1/htm/"; | |
| 512 | $c_s_gapdoc = hreftype($1, $bdir); | |
| 513 | } | |
| 514 | } elsif ($canon_name !~ /^($book):/) { | |
| 515 | $name = "$book:$name"; | |
| 516 | $canon_name = canonize $name; | |
| 517 | } | |
| 518 | $name =~ s/\s+/ /g; | |
| 519 | ||
| 520 | if (exists $redefined_secname{$canon_name}) { | |
| 521 | print STDERR "Ref to multiply defined label: ", | |
| 522 | "\"$name\" at line $. of $chap->{file}.tex\n"; | |
| 523 | } | |
| 524 | my $sec = $sections_by_name{$canon_name}; | |
| 525 | ||
| 526 | unless (defined ( $sec)) { | |
| 527 | print STDERR "Bad link: \"$name\" at line $. of $chap->{file}.tex\n"; | |
| 528 | return "badlink:$name"; | |
| 529 | } | |
| 530 | return $bdir . htm_fname($c_s_gapdoc, | |
| 531 | $sec->{chapnum}, | |
| 532 | ($ischap == 1) ? 0 : $sec->{secnum}, | |
| 533 | ($ischap == 1) ? 0 : $sec->{ssecnum}, | |
| 534 | $sec->{name}); | |
| 535 | } | |
| 536 | ||
| 537 | ||
| 538 | # strip out the tag from cross book references for the body of links | |
| 539 | sub name2linktext { | |
| 540 | my $name; | |
| 541 | ($name) = @_; | |
| 542 | $name =~ s/^(ref|tut|changes)://; | |
| 543 | return $name; | |
| 544 | } | |
| 545 | ||
| 546 | # | |
| 547 | # Add an index entry to the index. | |
| 548 | # ($hname = $fname or $fname#..., where $fname is a filename) | |
| 549 | sub add_to_index { | |
| 550 | my ($hname, $key, $sec) = @_; | |
| 551 | my $secno = "$sec->{chapnum}.$sec->{secnum}"; | |
| 552 | if (defined $sec->{ssecnum} and $sec->{ssecnum}) { | |
| 553 | $secno .= ".$sec->{ssecnum}"; | |
| 554 | } | |
| 555 | push @{$index{$key}}, [ $hname, $secno ]; | |
| 556 | # print STDERR "hname = $hname, key = $key, "; | |
| 557 | # print STDERR "sec = $secno\n"; | |
| 558 | } | |
| 559 | ||
| 560 | # | |
| 561 | # Create a label for an index entry, add it to the index if new, | |
| 562 | # and return the label (which is an empty string if not new). | |
| 563 | sub inxentry { | |
| 564 | my ($fname,$key,$sec) = @_; | |
| 565 | my $curs="$sec->{chapnum}.$sec->{secnum}"; | |
| 566 | # print STDERR "curs = $curs\n"; | |
| 567 | # print STDERR "fname = $fname, key = $key, "; | |
| 568 | # print STDERR "sec = $sec->{chapnum}.$sec->{secnum}\n"; | |
| 569 | my $label = "<a name = \"I$indexcount\"></a>\n"; | |
| 570 | if (defined $index{$key}) { | |
| 571 | my $ar; | |
| 572 | foreach $ar (@{$index{$key}}) { | |
| 573 | if ( ($ar->[1]) eq $curs ) { | |
| 574 | $label=""; # index entry is not new | |
| 575 | last; | |
| 576 | } | |
| 577 | } | |
| 578 | } else { | |
| 579 | $index{$key} = []; | |
| 580 | } | |
| 581 | if ($label ne "") { | |
| 582 | add_to_index("$fname#I$indexcount", $key, $sec); | |
| 583 | # print STDERR "$fname#I$indexcount\n"; | |
| 584 | $indexcount++; | |
| 585 | } | |
| 586 | return $label; | |
| 587 | } | |
| 588 | ||
| 589 | # | |
| 590 | # Return a NAME anchor for a subsection | |
| 591 | # | |
| 592 | sub subsec_name { | |
| 593 | my ($fname,$key,$sec) = @_; | |
| 594 | # print STDERR "curs = $curs\n"; | |
| 595 | # print STDERR "sec = $sec->{chapnum}.$sec->{secnum}.$sec->{ssecnum}\n"; | |
| 596 | $key =~ s/!\{(.*)\}$/!$1/; | |
| 597 | $key =~ s/\s+/ /g; | |
| 598 | my $canon_name = canonize "$book:$key"; | |
| 599 | my $sec_of_key = $sections_by_name{$canon_name}; | |
| 600 | if (exists $redefined_secname{$key}) { | |
| 601 | print STDERR "Multiply defined label: ", | |
| 602 | "\"$key\" at line $. of $chap->{file}.tex\n", | |
| 603 | "... subsection will be unreachable\n"; | |
| 604 | return ""; | |
| 605 | } elsif ($sec_of_key->{chapnum} ne $sec->{chapnum} || | |
| 606 | $sec_of_key->{secnum} ne $sec->{secnum}) { | |
| 607 | print STDERR "Section of \"$key\" (", | |
| 608 | "$sec_of_key->{chapnum}.$sec_of_key->{secnum}) ", | |
| 609 | "doesn't agree with the current section (", | |
| 610 | "$sec->{chapnum}.$sec->{secnum}) ", | |
| 611 | "at line $. of $chap->{file}.tex\n", | |
| 612 | "... subsection will be unreachable\n"; | |
| 613 | return ""; | |
| 614 | } else { | |
| 615 | my $curs = "$sec_of_key->{chapnum}.$sec_of_key->{secnum}" . | |
| 616 | ".$sec_of_key->{ssecnum}"; | |
| 617 | my $label = sec_label($opt_c, $sec_of_key->{chapnum}, | |
| 618 | $sec_of_key->{secnum}, | |
| 619 | $sec_of_key->{ssecnum}); | |
| 620 | if (defined $index{$key}) { | |
| 621 | my $ar; | |
| 622 | foreach $ar (@{$index{$key}}) { | |
| 623 | if ( ($ar->[1]) eq $curs ) { | |
| 624 | return ""; # index entry is not new | |
| 625 | } | |
| 626 | } | |
| 627 | } else { | |
| 628 | $index{$key} = []; | |
| 629 | } | |
| 630 | # print STDERR "Subsection key: \"$key\"\n"; | |
| 631 | add_to_index("$fname#$label", $key, $sec_of_key); | |
| 632 | return "<a name = \"$label\"></a>\n"; | |
| 633 | } | |
| 634 | } | |
| 635 | ||
| 636 | ||
| 637 | # Some characters must be represented differently in HTML. | |
| 638 | sub html_literal { | |
| 639 | my ($lit) = @_; | |
| 640 | if ($lit eq "<") { return "<"; } | |
| 641 | elsif ($lit eq ">") { return ">"; } | |
| 642 | elsif ($lit eq "&") { return "&"; } | |
| 643 | else { return $lit; } | |
| 644 | } | |
| 645 | ||
| 646 | ||
| 647 | # Gather lines ending in % together. | |
| 648 | sub gather { | |
| 649 | my ($line, $nontex) = @_; | |
| 650 | my $nextline; | |
| 651 | while ($line =~ s/%+\s*$// and defined($nextline = <IN>)) { | |
| 652 | $nextline =~ s/^%// if $nontex; | |
| 653 | unless ($nextline =~ /^%/) { | |
| 654 | $nextline =~ s/^\s*//; | |
| 655 | $line .= $nextline; | |
| 656 | chomp $line; | |
| 657 | } | |
| 658 | } | |
| 659 | return $line; | |
| 660 | } | |
| 661 | ||
| 662 | ||
| 663 | # This routine is called to process the text of the section | |
| 664 | # the output file is assumed to be pre-selected. The input filehandle | |
| 665 | # is simply IN | |
| 666 | # | |
| 667 | # As we process, we can be in "normal" mode (text), "maths" mode | |
| 668 | # inside $ ... $, or "verbatim" mode inside a multi-line example | |
| 669 | # | |
| 670 | # We separately track whether we are in bold or tt, | |
| 671 | # whether we are in a xxx: .... paragraph and whether we are reading | |
| 672 | # a cross-reference that is split across multiple lines | |
| 673 | # | |
| 674 | # Finally, we track whether we have already | |
| 675 | # emitted a <P> for this group of blank lines | |
| 676 | # | |
| 677 | ||
| 678 | ||
| 679 | $boldcommands = 'CAS|[A-Z]|danger|exercise'; | |
| 680 | $TeXbinops = "in|wedge|vee|cup|cap|otimes|oplus|le|ge|rightarrow"; | |
| 681 | $EndTeXMacro = "(?![A-Za-z])"; | |
| 682 | $TeXaccents = "\'`~=^"; # ^ must come last, this is also used as regexp | |
| 683 | # From these and the argument following the HTML symbol is built | |
| 684 | # e.g. `a -> à | |
| 685 | %accents = ( "\'" => "acute", "19" => "acute", | |
| 686 | "`" => "grave", "18" => "grave", | |
| 687 | "~" => "tilde", "126" => "tilde", | |
| 688 | "^" => "circ", "94" => "circ", | |
| 689 | "c" => "cedil", "48" => "cedil", | |
| 690 | "H" => "uml", "125" => "uml", "127" => "uml" ); | |
| 691 | # These are the replacements for accents that have an empty argument | |
| 692 | # or for which there is no single HTML symbol (so that the accent must | |
| 693 | # precede the argument) | |
| 694 | %acc_0arg = ( "\'" => "\'", "19" => "\'", | |
| 695 | "`" => "`", "18" => "`", | |
| 696 | "~" => "~", "126" => "~", | |
| 697 | "=" => "macr", "22" => "macr", | |
| 698 | "^" => "^", "94" => "^", | |
| 699 | "c" => "", "48" => "", # too hard ... just omit | |
| 700 | "d" => "", # too hard ... just omit | |
| 701 | "b" => "", # too hard ... just omit | |
| 702 | "t" => "", # too hard ... just omit | |
| 703 | "u" => "\\u", "21" => "\\u", # too hard ... put back | |
| 704 | "v" => "\\v", "20" => "\\v", # too hard ... put back | |
| 705 | "H" => "uml", "125" => "uml", "127" => "uml" ); | |
| 706 | ||
| 707 | # Calls tth to find out its version number | |
| 708 | sub tth_version { | |
| 709 | `tth -H >tthout 2> tthout`; | |
| 710 | open (TTHOUT, "<tthout") || die "Can't read tthout\n"; | |
| 711 | while (<TTHOUT>) { | |
| 712 | if (s/.*(Version [^ ]*).*/$1/) { | |
| 713 | close TTHOUT; | |
| 714 | system("rm tthout"); | |
| 715 | chomp; | |
| 716 | return $_; | |
| 717 | } | |
| 718 | } | |
| 719 | } | |
| 720 | ||
| 721 | ||
| 722 | # We use this routine when using -t option to do any maths translation | |
| 723 | sub tth_math_replace { | |
| 724 | my ($tth) = @_; | |
| 725 | open (TTHIN, ">tthin") || die "Can't create tthin"; | |
| 726 | #print STDERR "in: ${tth}\n"; | |
| 727 | my $tthorig = $tth; | |
| 728 | # replace <...> by proper TeX | |
| 729 | while ($tth =~ /(.*?[^\\])<(.*?[^\\])>(.*)/) { | |
| 730 | $tth= $1."{\\it ".$2."\\/}".$3; | |
| 731 | #print STDERR "tth: ${tth}\n"; | |
| 732 | } | |
| 733 | # replace `...' by proper TeX | |
| 734 | while ($tth =~ /(.*[^\\])`(.*[^\\])\'(.*)/) { | |
| 735 | $tth= $1."{\\tt ".$2."}".$3; | |
| 736 | } | |
| 737 | # replace \< by proper TeX | |
| 738 | while ($tth =~ /(.*[^\\])\\<(.*)/) { | |
| 739 | $tth= $1."<".$2; | |
| 740 | } | |
| 741 | #while ($tth =~ /(.*[^\\])\\>(.*)/) { | |
| 742 | # $tth= $1.">".$2; | |
| 743 | #} | |
| 744 | ||
| 745 | $tth =~ s/([^\\]|^)([.])/$1\\cdot /g; # . not preceded by \ becomes \cdot | |
| 746 | $tth =~ s/\\[.]/./g; # \. becomes . | |
| 747 | $tth =~ s/(\\right)\\cdot/$1./g; # ... except for \right. (leave as is) | |
| 748 | $tth =~ s/(\\not)\s*/$1/g; | |
| 749 | $tth =~ s/\\\*/*/g; | |
| 750 | if ($opt_t < 2.52) { | |
| 751 | $tth =~ s/\\not\\in(?![a-zA-Z])/\\notin/g; | |
| 752 | $tth =~ s/\\not\\subset/ not subset/g; | |
| 753 | } | |
| 754 | # Ensure display mode used for \buildrel and \choose constructions | |
| 755 | $tth =~ s/\$/\$\$/g if ($tth =~ /\\buildrel|\\choose/ and $tth !~ /\$\$/); | |
| 756 | if ($tth =~ /\\[A-Za-z]/) { | |
| 757 | # there might be macros: Load our macros | |
| 758 | #print STDERR "tth: ${tth}\n"; | |
| 759 | print TTHIN "\\input tthmacros.tex\n"; | |
| 760 | } | |
| 761 | # we put in TTHBEGIN .. TTHEND | |
| 762 | # so we can strip out the superfluous <p>s | |
| 763 | # tth 2.78+ puts in, later. | |
| 764 | print TTHIN "TTHBEGIN${tth}TTHEND\n"; | |
| 765 | close TTHIN; | |
| 766 | `$tthbin -r -i <tthin >tthout 2>/dev/null`; | |
| 767 | open (TTHOUT, "<tthout") || die "Can't read tthout"; | |
| 768 | $tth=""; | |
| 769 | while ( $tthin = <TTHOUT> ) { | |
| 770 | chomp($tthin); | |
| 771 | $tth .= $tthin; | |
| 772 | } | |
| 773 | close TTHOUT; | |
| 774 | #print STDERR "out: ${tth}\n"; | |
| 775 | # only the stuff between TTHBEGIN and TTHEND | |
| 776 | # actually belongs to the formula translated | |
| 777 | $tth =~ s/.*TTHBEGIN(.*)TTHEND.*/$1/ | |
| 778 | || do {print STDERR "!tth failed with input:\n $tthorig\n", | |
| 779 | "!Null formula written to HTML file\n"; | |
| 780 | $tth = "";}; | |
| 781 | # tth leaves \mathbin etc. in ... get rid of them if present | |
| 782 | $tth =~ s/\\math(bin|rel|op)//g; | |
| 783 | # TtH up to version 2.86 doesn't know the following | |
| 784 | $tth =~ s/\\wr(?![a-zA-Z])/ wr /g; | |
| 785 | $tth =~ s/\\vdash(?![a-zA-Z])/ |- /g; | |
| 786 | $tth =~ s/\\tilde(?![a-zA-Z])/~/g; # needed for in-line maths | |
| 787 | #print STDERR "stripped: ${tth}\n"; | |
| 788 | ||
| 789 | # replace italic typewriter (happens because we force | |
| 790 | # italic letters) by roman typewriter style | |
| 791 | while ($tth =~ /(.*)<tt><i>(.*)<\/i><\/tt>(.*)/) { | |
| 792 | $tth= $1."<tt>".$2."</tt>".$3; | |
| 793 | } | |
| 794 | ||
| 795 | # increasing the font size doesn't affect maths displays | |
| 796 | # ... and `...' markup doesn't get increased in font size | |
| 797 | # So let's get rid of it. | |
| 798 | #$tth = "<font size=\"+1\">$tth</font>"; | |
| 799 | #print STDERR "enlarged: ${tth}\n"; | |
| 800 | return $tth; | |
| 801 | } | |
| 802 | ||
| 803 | # | |
| 804 | # Takes a line of form: "<head><spaces>{<arg>}<rest>" | |
| 805 | # and returns an array with: <rest>, <arg>, <head> | |
| 806 | # i.e. it finds the matching } for {. | |
| 807 | sub get_arg { | |
| 808 | my ($line) = @_; | |
| 809 | if ($line =~ /\s*\{([^{}]*)/) { | |
| 810 | $line = $`; | |
| 811 | my $arg = $1; | |
| 812 | my $rest = $'; | |
| 813 | my $nbraces = 1; | |
| 814 | while ($nbraces) { | |
| 815 | if ($rest =~ s/^(\{[^{}]*)//) { | |
| 816 | $arg .= $1; | |
| 817 | $nbraces++; | |
| 818 | } elsif ($nbraces == 1 and $rest =~ s/^\}//) { | |
| 819 | $nbraces--; | |
| 820 | } elsif ($rest =~ s/^(\}[^{}]*)//) { | |
| 821 | $arg .= $1; | |
| 822 | $nbraces--; | |
| 823 | } else { # abort ... but make sure braces match | |
| 824 | $rest = "{" x $nbraces . $rest; | |
| 825 | $arg .= "}" x ($nbraces - 1); | |
| 826 | $nbraces = 0; | |
| 827 | } | |
| 828 | } | |
| 829 | return ($rest, $arg, $line); | |
| 830 | } else { | |
| 831 | print STDERR "line:$line\n"; | |
| 832 | die "Expected argument: at line $. of file"; | |
| 833 | } | |
| 834 | } | |
| 835 | ||
| 836 | # | |
| 837 | # Given an accent macro with the \ or \accent stripped and the rest | |
| 838 | # of a line with the macro's argument at it beginning return the | |
| 839 | # HTML version of the accented argument and rest after the macro's | |
| 840 | # argument has been stripped from it. | |
| 841 | sub do_accent { | |
| 842 | my ($rest, $macro) = @_; | |
| 843 | $rest =~ /^(\w)|\{(\w?)\}/; | |
| 844 | $rest = $'; | |
| 845 | my $arg = (defined $1) ? $1 : $2; | |
| 846 | $macro = ($arg eq "") ? $acc_0arg{$macro} : "&$arg$accents{$macro};"; | |
| 847 | return ($rest, $macro); | |
| 848 | } | |
| 849 | ||
| 850 | # | |
| 851 | # Takes rest which has a TeX macro without its \ at its beginning and | |
| 852 | # returns the HTML version of the TeX macro and rest with the TeX macro | |
| 853 | # stripped from it. | |
| 854 | sub macro_replace { | |
| 855 | my ($rest) = @_; | |
| 856 | if ($rest =~ /^([$TeXaccents])\s*/) { | |
| 857 | return do_accent($', $1); | |
| 858 | } | |
| 859 | if ($rest =~ /^([a-zA-Z]+)\s*/) { | |
| 860 | $rest = $'; | |
| 861 | my $macro = $1; | |
| 862 | if ($macro eq "accent") { | |
| 863 | $rest =~ /^(\d+)\s*/; | |
| 864 | $rest = $'; | |
| 865 | $macro = $1; | |
| 866 | $macro = "" unless (defined $acc_0arg{$macro}); | |
| 867 | } | |
| 868 | if (defined $accents{$macro}) { return do_accent($rest, $macro); } | |
| 869 | elsif (defined $acc_0arg{$macro}) { return ($rest, $acc_0arg{$macro}); } | |
| 870 | elsif ($macro eq "copyright") { return ($rest, "©"); } | |
| 871 | elsif ($macro eq "aa") { return ($rest, "å"); } | |
| 872 | elsif ($macro eq "AA") { return ($rest, "Å"); } | |
| 873 | elsif ($macro eq "lq") { return ($rest, "`"); } | |
| 874 | elsif ($macro =~ /^(rq|pif)$/) { return ($rest, "'"); } | |
| 875 | elsif ($macro =~ /^($boldcommands)$/) | |
| 876 | { return ($rest,"<font face=\"helvetica,arial\">".uc($&)."</font>"); } | |
| 877 | elsif ($macro =~ /^(GAP|ATLAS|MOC$sharepkg)$/) | |
| 878 | { return ($rest, sansserif $macro); } | |
| 879 | elsif ($macro eq "package") | |
| 880 | { my ($last, $arg, $first) = get_arg("$rest"); # $first = "" | |
| 881 | return ($last, sansserif $arg);} | |
| 882 | elsif ($macro eq "sf") | |
| 883 | { my ($last, $arg, $first) = get_arg("{$rest"); # $first = "" | |
| 884 | return ($last, sansserif $arg);} | |
| 885 | elsif ($macro =~ /^([hv]box|rm|kernttindent|math(bin|rel|op))$/) | |
| 886 | { return ($rest, "");} | |
| 887 | elsif ($macro =~ /^(obeylines|(begin|end)group)$/) | |
| 888 | { return ($rest, "");} | |
| 889 | elsif ($macro =~ /^hfil(|l)$/) { return ($rest, " ");} | |
| 890 | elsif ($macro =~ /^break$/) { return ($rest, "<br>");} | |
| 891 | elsif ($macro =~ /^(it|sl)$/) | |
| 892 | { my ($last, $arg, $first) = get_arg("{$rest"); # $first = "" | |
| 893 | return ("$arg}\\emphend $last", "<em>");} | |
| 894 | # pseudo ``emph'' end token | |
| 895 | elsif ($macro eq "emphend") { return ($rest, "</em>"); } | |
| 896 | elsif ($macro eq "hrule") { return ($rest, "<hr>"); } | |
| 897 | elsif ($macro eq "enspace") { return ($rest, " "); } | |
| 898 | elsif ($macro eq "quad") { return ($rest, " "); } | |
| 899 | elsif ($macro eq "qquad") { return ($rest, " "); } | |
| 900 | elsif ($macro eq "ss") { return ($rest, "ß"); } | |
| 901 | elsif ($macro eq "o") { return ($rest, "ø"); } | |
| 902 | elsif ($macro eq "O") { return ($rest, "Ø"); } | |
| 903 | elsif ($macro =~ /^l?dots$/) { return ($rest, "..."); } | |
| 904 | elsif ($macro =~ /^bs?f|stars$/) { return ($rest, "<hr>"); } | |
| 905 | elsif ($macro eq "cr") { return ($rest, "<br>"); } | |
| 906 | # <li> in the next line would be invalid HTML | |
| 907 | elsif ($macro eq "fmark") { return ($rest, " "); } | |
| 908 | elsif ($macro eq "item") | |
| 909 | { ($rest, $itemarg, $first) = get_arg("$rest"); # $first = "" | |
| 910 | if ($listdepth == 2) { | |
| 911 | $listdepth = 1; | |
| 912 | if ($listtype eq "d") { | |
| 913 | return ("$itemarg\\itmnd $rest", "\n</dl>\n<dt>"); | |
| 914 | } else { #ignore bit in braces (ordered and unordered lists) | |
| 915 | return ($rest, "\n</${listtype}l>\n<li>"); | |
| 916 | } | |
| 917 | } else { | |
| 918 | if ($listtype eq "d") { | |
| 919 | return ("$itemarg\\itmnd $rest", "<dt>"); | |
| 920 | } else { #ignore bit in braces (ordered and unordered lists) | |
| 921 | return ($rest, "<li>"); | |
| 922 | } | |
| 923 | } | |
| 924 | } | |
| 925 | elsif ($macro eq "itemitem") | |
| 926 | { ($rest, $itemarg, $first) = get_arg("$rest"); # $first = "" | |
| 927 | $rest =~ /^(%(un|)ordered)? #defines $sublisttype | |
| 928 | (\{([1aAiI])\})? #defines TYPE of ordered sublist | |
| 929 | (\{(\d+)\})? #defines START of ordered sublist | |
| 930 | /x; | |
| 931 | if ($listdepth == 1) { | |
| 932 | $sublisttype = list_type($1, $2); | |
| 933 | $sublistentry = begin_list($sublisttype, $3, $4, $5, $6) . "\n"; | |
| 934 | $listdepth = 2; | |
| 935 | } else { | |
| 936 | $sublistentry = ""; | |
| 937 | } | |
| 938 | if ($sublisttype eq "d") { | |
| 939 | return ("$itemarg\\itmnd $rest", "$sublistentry<dt>"); | |
| 940 | } else { #ignore bit in braces (ordered and unordered lists) | |
| 941 | return ($rest, "$sublistentry<li>"); | |
| 942 | } | |
| 943 | } | |
| 944 | # pseudo ``itemend'' character | |
| 945 | elsif ($macro eq "itmnd") { return ($rest, "<dd>"); } | |
| 946 | elsif ($macro eq "cite" and $rest =~ /^\{\s*(\S+)\s*\}/) | |
| 947 | { return ($', "<a href=\"biblio.htm#$1\"><cite>$1</cite></a>"); } | |
| 948 | elsif ($macro eq "URL" and $rest =~ /^\{([^\}]*)\}/) | |
| 949 | { return ($', "<a href=\"$1\">$1</a>"); } | |
| 950 | elsif ($macro eq "Mailto" and $rest =~ /^\{([^\}]*)\}/) | |
| 951 | { return ($', "<a href=\"mailto:$1\">$1</a>"); } | |
| 952 | else { return ($rest, $macro); } | |
| 953 | } elsif ($rest =~ /^-/) { | |
| 954 | return ($', ""); # hyphenation help -- ignore | |
| 955 | } elsif ($rest =~ /^</) { | |
| 956 | return ($', "<"); | |
| 957 | } elsif ($rest =~ /^\&/) { | |
| 958 | return ($', "&"); | |
| 959 | } else { | |
| 960 | $rest =~ /^./; | |
| 961 | return ($', $&); | |
| 962 | } | |
| 963 | } | |
| 964 | ||
| 965 | # Returns the type of a list | |
| 966 | ||
| 967 | sub list_type { | |
| 968 | my ($type, $un) = @_; | |
| 969 | return ( !(defined $type) ) ? "d" #descriptive | |
| 970 | : ($un eq "un") | |
| 971 | ? "u" #unordered | |
| 972 | : "o"; #ordered | |
| 973 | } | |
| 974 | ||
| 975 | # Returns a string for starting a list of the appropriate type | |
| 976 | ||
| 977 | sub begin_list { | |
| 978 | my ($listtype, $otypedef, $otype, $ostartdef, $ostart) = @_; | |
| 979 | my $beginlist = "<${listtype}l"; | |
| 980 | if ($listtype eq "d") { | |
| 981 | $beginlist .= " compact"; | |
| 982 | } elsif ($listtype eq "o") { | |
| 983 | if ( (defined $otypedef) && (defined $otype) ) { | |
| 984 | $beginlist .= " type=$otype"; | |
| 985 | if ( (defined $ostartdef) && (defined $ostart) ) { | |
| 986 | $beginlist .= " start=$ostart"; | |
| 987 | } | |
| 988 | } | |
| 989 | } | |
| 990 | $beginlist .= ">"; | |
| 991 | return $beginlist; | |
| 992 | } | |
| 993 | ||
| 994 | # | |
| 995 | # This could probably be done more cleverly -- this routine is too long | |
| 996 | # | |
| 997 | ||
| 998 | sub convert_text { | |
| 999 | my $fname = $_[0]; | |
| 1000 | my $refchars = '[\-\\w\\s`\',./:!()?$]'; # these make up cross references | |
| 1001 | my $ref = ""; | |
| 1002 | my $endline = ""; # used for </code> at the end of line | |
| 1003 | my $mode = "normal"; # $mode can be: | |
| 1004 | # "normal" : TeX macros need to be interpreted | |
| 1005 | # "verbatim" : No interpretation done, except that | |
| 1006 | # || is converted to |. | |
| 1007 | # "html" : No interpretation done, except that | |
| 1008 | # initial % is removed. | |
| 1009 | # "maths" : A variant of "normal" where inside | |
| 1010 | # $...$ or $$...$$ (TeX's math mode) | |
| 1011 | my $ttenv = 0; # $ttenv is set to 1 in \begintt .. \endtt "verbatim" mode | |
| 1012 | my $nontex = 0; # $nontex is set to 1 in %display{nontex} and | |
| 1013 | # %display{nontext} env'ts, for which $mode is "normal" | |
| 1014 | # but initial % of each line is removed. | |
| 1015 | my $skip_lines = 0; # $skip_lines is set non-zero in %display{tex}, | |
| 1016 | # %display{text}, %display{jpeg}, %display{nonhtml} | |
| 1017 | # and \answer env'ts | |
| 1018 | my ($bold,$tt,$it,$sub,$sup,$inlist,$inref,$donepar) = (0,0,0,0,0,0,0); | |
| 1019 | my ($indexarg,$indexarg2,$zwei,$drei,$vier,$macro,$endmath,$endmathstring); | |
| 1020 | ||
| 1021 | # | |
| 1022 | # Now we loop over lines. a line with 16 initial % signs marks | |
| 1023 | # end of section | |
| 1024 | # | |
| 1025 | ||
| 1026 | LINE: while (defined($_ = <IN>) and not /^\%{16,}/) { | |
| 1027 | chomp; # drop the trailing newline | |
| 1028 | my $rest = $_; # rest of the line to scan | |
| 1029 | my $outline = ""; # build the output in here | |
| 1030 | ||
| 1031 | # First we deal with various special whole lines. | |
| 1032 | # \beginexample, \begintt, %display (this may end a $skip_lines) | |
| 1033 | if ($mode eq "normal" and /^\\begin(example|tt)/) { | |
| 1034 | if ($_ =~ /^\\begintt/) { # This is to catch a \begintt .. \endtt | |
| 1035 | $ttenv = 1; # environment enclosing \beginexample .. | |
| 1036 | } # \endexample | |
| 1037 | $mode = "verbatim"; | |
| 1038 | $skip_lines = 0; | |
| 1039 | print "<pre>\n"; | |
| 1040 | next LINE; | |
| 1041 | } elsif ($mode eq "normal" and /^%display\{nontex(|t)\}/) { | |
| 1042 | $nontex = 1; | |
| 1043 | $skip_lines = 0; | |
| 1044 | next LINE; | |
| 1045 | } elsif ($mode eq "normal" and /^%display\{(text?|jpeg|nonhtml)\}/) { | |
| 1046 | # Paragraphs to be skipped by HTML. | |
| 1047 | $mode = "normal"; | |
| 1048 | $nontex = 0; | |
| 1049 | $skip_lines = 2; | |
| 1050 | next LINE; | |
| 1051 | } elsif ($mode eq "normal" and /^%display\{html\}/) { | |
| 1052 | $mode = "html"; | |
| 1053 | $skip_lines = 0; | |
| 1054 | } elsif ($mode eq "html" and /^%display\{text\}/) { | |
| 1055 | $mode = "normal"; | |
| 1056 | $nontex = 0; | |
| 1057 | $skip_lines = 2; | |
| 1058 | next LINE; | |
| 1059 | } elsif (/^%enddisplay/ and !$ttenv) { | |
| 1060 | if ($mode eq "verbatim") { | |
| 1061 | print "</pre>\n"; | |
| 1062 | } | |
| 1063 | $mode = "normal"; | |
| 1064 | $nontex = 0; | |
| 1065 | $skip_lines = 0; | |
| 1066 | next LINE; | |
| 1067 | } elsif ($mode eq "verbatim") { | |
| 1068 | # \endexample, \endtt | |
| 1069 | if (/^\\endtt/ or (/^\\endexample/ and !$ttenv)) { | |
| 1070 | $mode = "normal"; | |
| 1071 | $ttenv = 0; | |
| 1072 | print "</pre>\n"; | |
| 1073 | next LINE; | |
| 1074 | } | |
| 1075 | # |_ | |
| 1076 | if (/^\|_/) { | |
| 1077 | next LINE; | |
| 1078 | } | |
| 1079 | } elsif ($mode eq "html") { | |
| 1080 | if (/^%/) { | |
| 1081 | print "$'\n"; | |
| 1082 | } else { | |
| 1083 | print STDERR "Line $. ignored in \%display{html} mode, " . | |
| 1084 | "because it didn't start with \%\n"; | |
| 1085 | } | |
| 1086 | next LINE; | |
| 1087 | } elsif ((!$nontex and /^%/) || | |
| 1088 | (!/\\(at|)index/ and /^([{}]|\s*\{?\\[a-zA-Z].*)%$/)) { | |
| 1089 | # Ignore lines starting with a % except if in html or verbatim | |
| 1090 | # modes (dealt with above) or if in nontex mode which we deal | |
| 1091 | # with below. | |
| 1092 | # Also ignore specific lines ending in a % (we have to be careful | |
| 1093 | # here -- % also indicates a continuation). The lines we ignore are | |
| 1094 | # those that match: "{%", "}%", "{\\X..%", "\\X..%" where X denotes | |
| 1095 | # any letter and .. any sequence of chars. This is meant to exclude | |
| 1096 | # lines like "{\obeylines ... %", "\begingroup ... %". If this proves | |
| 1097 | # problematic the .tex files will need to use the %display{tex} env't | |
| 1098 | # to exclude such lines. | |
| 1099 | next LINE; | |
| 1100 | ||
| 1101 | # All that's left are whole lines that occur in "normal" mode | |
| 1102 | } else { | |
| 1103 | ||
| 1104 | # Line skipping. | |
| 1105 | if ($skip_lines) { | |
| 1106 | if ($skip_lines == 1 and $_ =~ /^\s*$/) { | |
| 1107 | $skip_lines = 0; | |
| 1108 | } | |
| 1109 | next LINE; | |
| 1110 | } | |
| 1111 | ||
| 1112 | # Remove initial % if there is one when in %display{nontex} or | |
| 1113 | # %display{nontext} environment | |
| 1114 | if ($nontex) { | |
| 1115 | s/^%//; | |
| 1116 | $rest = $_; | |
| 1117 | } | |
| 1118 | # a '%' at end-of-line indicates a continuation | |
| 1119 | $_ = gather($_, $nontex); | |
| 1120 | ||
| 1121 | # Paragraphs are ended by blank lines. | |
| 1122 | if (/^\s*$/) { | |
| 1123 | unless ($donepar) { | |
| 1124 | $outline .= "<p>\n"; | |
| 1125 | $donepar = 1; | |
| 1126 | } | |
| 1127 | ||
| 1128 | # If we get to the end of a paragraph we assume that we have | |
| 1129 | # lost track of what is going on, warn and try to resume. | |
| 1130 | if ($mode eq "maths" or $inref) { | |
| 1131 | print STDERR "Paragraph ended in $mode mode at $.\n" . | |
| 1132 | "reverting to normal\n"; | |
| 1133 | $outline .= "</I>" if ($mode eq "maths"); | |
| 1134 | $mode = "normal"; | |
| 1135 | } | |
| 1136 | ||
| 1137 | print $outline; | |
| 1138 | next LINE; | |
| 1139 | } | |
| 1140 | # Vertical skips. | |
| 1141 | if (/^\\(med|big)skip/) { | |
| 1142 | $outline .= "<p>"; | |
| 1143 | print "$outline\n"; | |
| 1144 | next LINE; | |
| 1145 | } | |
| 1146 | # Index entries -- emit an anchor and remember the index | |
| 1147 | # keys for later there may be several on one line and | |
| 1148 | # several references to one key | |
| 1149 | if (/^\\(at|)index/) { | |
| 1150 | # $_ = gather($_, $nontex); # already done above | |
| 1151 | while (/\\((at|)index(tt|))\{/g) { | |
| 1152 | ($rest, $indexarg) = (get_arg("{".$'))[0,1]; | |
| 1153 | if ($1 eq "atindex") { | |
| 1154 | ($indexarg2) = (get_arg($rest))[1]; | |
| 1155 | if ($indexarg2 =~ /^@/) { | |
| 1156 | $indexarg = $'; | |
| 1157 | $indexarg =~ s/\\noexpand\s*`([^']*)'/$1/g; | |
| 1158 | $indexarg =~ s/\\noexpand\s*<([^>]*)>/$1/g; | |
| 1159 | $indexarg =~ s/\\noexpand//g; | |
| 1160 | $indexarg =~ s/\|.*//; # remove "|indexit" if present | |
| 1161 | # $indexarg might still have macros ... | |
| 1162 | # we should do something about these too | |
| 1163 | } | |
| 1164 | } | |
| 1165 | # Just the crudest form of macro removal - probably enough | |
| 1166 | $indexarg =~ s/\\(.)/$1/g; | |
| 1167 | $indexarg =~ s/\$//g; #assume $s match in pairs!! | |
| 1168 | $bla = inxentry($fname,$indexarg,$sec); | |
| 1169 | $outline .= $bla; | |
| 1170 | print "$outline\n"; | |
| 1171 | } | |
| 1172 | next LINE; | |
| 1173 | } | |
| 1174 | # \> and \) lines (joined with next line if ending in %) | |
| 1175 | if (/^\\[>)]/) { | |
| 1176 | # $_ = gather($_, $nontex); # already done above | |
| 1177 | # if \> with ` or ( without a matching ' or ) gather lines | |
| 1178 | if ( /^\\> *\`/ ) { # line should have ended in a % | |
| 1179 | while ( !/\'/ ) { $_ = gather("$_%", $nontex); } | |
| 1180 | } elsif ( /^\\>.*\(/ ) { # line should have ended in a % | |
| 1181 | while ( !/\)/ ) { $_ = gather("$_%", $nontex); } | |
| 1182 | } | |
| 1183 | # get rid of @{...} or @`...' if present. | |
| 1184 | if (/@/) { | |
| 1185 | # print STDERR "before:$_\n"; | |
| 1186 | if (s/@\s*(\{[^{}]*\}|\`[^\']*\')\s*/ /) { # easy | |
| 1187 | } elsif (/@\s*/) { | |
| 1188 | # nested braces ... need to find matching brace | |
| 1189 | $_ = $`; | |
| 1190 | ($rest) = get_arg($'); | |
| 1191 | $_ .= " $rest"; | |
| 1192 | $rest =""; | |
| 1193 | } | |
| 1194 | # print STDERR "after:$_\n"; | |
| 1195 | print STDERR "@ still present at $_" if (/@/); | |
| 1196 | } | |
| 1197 | } | |
| 1198 | # if there is a comment in square brackets we extract it now | |
| 1199 | # ... this way if this feature is undesirable we can easily get | |
| 1200 | # rid of it | |
| 1201 | my $comment = ""; | |
| 1202 | # These cases [<something>] is not a comment: | |
| 1203 | # \><anything>; # [<arg>] here is treated as an optional arg | |
| 1204 | # \>`<func-with-args>'{<func>![gdfile]} # possibility from | |
| 1205 | # # buildman.pe \Declaration | |
| 1206 | if (/^\\>(.*;|`[^\']+\'\{[^}!]*!\[[^\]]*\]})/) { | |
| 1207 | ; | |
| 1208 | } elsif (/^\\>.*\(/) { | |
| 1209 | if (s/^(\\>[^(]*\([^)]*\)[^\[]*)(\[[^\]]*\])/$1/) { | |
| 1210 | $comment = " $2"; | |
| 1211 | } | |
| 1212 | } elsif (s/^(\\>[^\[]*)(\[[^\]]*\])/$1/) { | |
| 1213 | $comment = " $2"; | |
| 1214 | } | |
| 1215 | # \>`<variable>' V | |
| 1216 | if (/^\\> *`([^\']+)\'\s*(\[[^\]]*\])?\s*V?\s*$/) { | |
| 1217 | $endline = "</code>"; | |
| 1218 | $outline .= subsec_name($fname,$1,$sec); # $1 = <variable> | |
| 1219 | $outline .= "<dt>" if $inlist; | |
| 1220 | $outline .= "<li><code>"; | |
| 1221 | $tt = 1; | |
| 1222 | $rest = $1.$comment." V"; | |
| 1223 | } | |
| 1224 | # \>`<non-func>'{<label>}[!<sub-entry>][ <capital>] | |
| 1225 | # <capital> is usually one of A-Z (but any non-space will be matched) | |
| 1226 | elsif (/^\\> *`([^\']+)\'\s*\{([^}]+)\}(!\{.*\})?\s*([^\s]+)?\s*$/) { | |
| 1227 | # $1 = <non-func> $2 = <label> [$3 = !<sub-entry>][$4 = <capital>] | |
| 1228 | $endline = "</code>"; | |
| 1229 | $drei = defined($3) ? $3 : ""; | |
| 1230 | $vier = defined($4) ? " $4" : ""; | |
| 1231 | # $2$drei = <label><sub-entry> | |
| 1232 | $outline .= subsec_name($fname,"$2$drei",$sec); | |
| 1233 | #print STDERR "non-func:$1 - $2 - $drei - $vier |$2$drei|\n"; | |
| 1234 | $outline .= "<dt>" if $inlist; | |
| 1235 | $outline .= "<li><code>"; | |
| 1236 | $tt = 1; | |
| 1237 | $rest = $1.$comment.$vier; | |
| 1238 | } | |
| 1239 | # \><func>[(<args>)][!{<sub-entry>}][ <capital>] | |
| 1240 | # <capital> is usually one of A-Z (but any non-space will be matched) | |
| 1241 | elsif (/^\\> *([^(]+)(\([^)]*\))?(!\{.*\})?\s*([^\s]+)?\s*$/) { | |
| 1242 | # $1 = <func> $2 = (<args>) [$3 = !<sub-entry>][$4 = <capital>] | |
| 1243 | $endline = "</code>"; | |
| 1244 | $zwei = defined($2) ? $2 : ""; | |
| 1245 | $drei = defined($3) ? $3 : ""; | |
| 1246 | $vier = defined($4) ? " $4" : ""; | |
| 1247 | $outline .= subsec_name($fname,"$1$drei",$sec); | |
| 1248 | # $1$drei = <func><sub-entry> | |
| 1249 | #print STDERR "func:$1 - $zwei - $drei - $vier |$1$drei|\n"; | |
| 1250 | $outline .= "<dt>" if $inlist; | |
| 1251 | $outline .= "<li><code>"; | |
| 1252 | $tt = 1; | |
| 1253 | $rest = $1.$zwei.$comment.$vier; | |
| 1254 | ||
| 1255 | } | |
| 1256 | elsif (/^\\\>/) { | |
| 1257 | die "Didn't find an appropriate \\> match for $_ ... syntax?"; | |
| 1258 | } | |
| 1259 | elsif (/^\\\) *(.*)$/) { | |
| 1260 | $endline = "</code>"; | |
| 1261 | $outline .= "<dt>" if $inlist; | |
| 1262 | if ($donepar) { | |
| 1263 | $outline .= "<code>"; | |
| 1264 | } else { | |
| 1265 | $outline .= "<br><code>"; | |
| 1266 | } | |
| 1267 | $tt = 1; | |
| 1268 | $rest = $1; | |
| 1269 | # Skip all other lines starting or ending in % or containing | |
| 1270 | # `align'. | |
| 1271 | } elsif ($mode ne "verbatim" and | |
| 1272 | $_ =~ /^\s*%|%\s*$|\\[a-z]+align/) { | |
| 1273 | next LINE; | |
| 1274 | } | |
| 1275 | } | |
| 1276 | ||
| 1277 | # Here we have a "non-special" line to process We scan it for | |
| 1278 | # special characters and deal with them individually $rest | |
| 1279 | # contains the text that we have yet to look at We accumulate | |
| 1280 | # the output in $outline, rather than printing it because a & | |
| 1281 | # requires us to back up to start of line | |
| 1282 | $donepar = 0; | |
| 1283 | ||
| 1284 | # The (rare) situation that we are processing a multi-line cross | |
| 1285 | # reference is handled specially. | |
| 1286 | if ($inref) { | |
| 1287 | # if it finishes on this line emit the link | |
| 1288 | # otherwise keep accumulating it | |
| 1289 | if ($rest =~ /^$refchars+\"/o) { | |
| 1290 | $rest = $'; | |
| 1291 | chop($ref .= $&); | |
| 1292 | $ref1 = name2fn($ref,0); | |
| 1293 | $ref2 = name2linktext($ref); | |
| 1294 | $outline .= "<a href=\"$ref1\">$ref2</a>"; | |
| 1295 | $inref = "0"; | |
| 1296 | } elsif ($rest =~ /^$refchars*$/o) { | |
| 1297 | $ref .= "$rest "; | |
| 1298 | next LINE; | |
| 1299 | } else { | |
| 1300 | die "Bad reference. So far $ref, now got $rest"; | |
| 1301 | } | |
| 1302 | } | |
| 1303 | ||
| 1304 | # || really means | in verbatim mode | |
| 1305 | $rest =~ s/\|\|/\|/g if ($mode eq "verbatim"); | |
| 1306 | ||
| 1307 | # The main case, scan for special characters. | |
| 1308 | SPECIAL: while ( $rest =~ /[\\{}\$<>`\'*\"&%~_^]/ ) { | |
| 1309 | $outline .= $`; # the part that we scanned past | |
| 1310 | $rest = $'; # the remainder | |
| 1311 | my $matched = $&; # the character matched | |
| 1312 | ||
| 1313 | # In verbatim mode, everything is passed to HTML. | |
| 1314 | if ($mode eq "verbatim") { | |
| 1315 | # if ($matched ne "%") { | |
| 1316 | $outline .= html_literal $matched; | |
| 1317 | # } | |
| 1318 | next SPECIAL; | |
| 1319 | } | |
| 1320 | ||
| 1321 | # backslash | |
| 1322 | if ($matched eq "\\") { | |
| 1323 | # commands that begin a new output line | |
| 1324 | NEWLINE: { | |
| 1325 | if ($rest =~ /^beginitems/ and not $inlist) { | |
| 1326 | $outline .= "<p>\n<dl compact>"; | |
| 1327 | $inlist = 1; | |
| 1328 | } elsif ($rest =~ /^enditems/ and $inlist) { | |
| 1329 | $outline .= "</dl>"; | |
| 1330 | $inlist = 0; | |
| 1331 | } elsif ($rest =~ /^beginlist | |
| 1332 | (%(un|)ordered)? #defines $listtype | |
| 1333 | (\{([1aAiI])\})? #defines TYPE of ordered list | |
| 1334 | (\{(\d+)\})? #defines START of ordered list | |
| 1335 | /x ) { | |
| 1336 | $listtype = list_type($1, $2); | |
| 1337 | $outline .= begin_list($listtype, $3, $4, $5, $6); | |
| 1338 | $listdepth = 1; | |
| 1339 | } elsif ($rest =~ /^endlist/) { | |
| 1340 | $outline .= ("</${listtype}l>") x $listdepth; | |
| 1341 | $listdepth = 0; | |
| 1342 | } elsif ($rest =~ /^answer/) { | |
| 1343 | $outline = ""; | |
| 1344 | $skip_lines = 1; | |
| 1345 | } else { | |
| 1346 | last NEWLINE; | |
| 1347 | } | |
| 1348 | print "$outline\n"; | |
| 1349 | next LINE; | |
| 1350 | } | |
| 1351 | # commands that are replaced by HTML text | |
| 1352 | REPLACE: { | |
| 1353 | ($rest, $macro) = macro_replace($rest); | |
| 1354 | $outline .= $macro; | |
| 1355 | next SPECIAL; | |
| 1356 | } | |
| 1357 | # Try to get nice spacing around certain maths constructs that | |
| 1358 | # are used a lot. | |
| 1359 | if ($mode eq "maths") { | |
| 1360 | MATHREPLACE: { | |
| 1361 | if ($rest =~/^($TeXbinops)$EndTeXMacro/o) { | |
| 1362 | $outline .= " $1 "; } | |
| 1363 | elsif ($rest =~/^backslash$EndTeXMacro/o) { | |
| 1364 | $outline .= " \\ "; } | |
| 1365 | elsif ($rest =~/^split$EndTeXMacro/o) { | |
| 1366 | $outline .= ":"; } | |
| 1367 | elsif ($rest =~/^langle$EndTeXMacro/o) { | |
| 1368 | $outline .= " <"; } | |
| 1369 | elsif ($rest =~ /^rangle$EndTeXMacro/o) { | |
| 1370 | $outline .= "> "; } | |
| 1371 | else { last MATHREPLACE; } | |
| 1372 | $rest = $'; | |
| 1373 | next SPECIAL; | |
| 1374 | } | |
| 1375 | } | |
| 1376 | # Take the next character literally. | |
| 1377 | if ($rest ne "") { | |
| 1378 | $outline .= html_literal substr($rest,0,1); | |
| 1379 | $rest = substr($rest,1); | |
| 1380 | } | |
| 1381 | next SPECIAL; | |
| 1382 | } | |
| 1383 | ||
| 1384 | # Subscripts and superscripts in math mode. | |
| 1385 | if ($mode eq "maths" and !$sub and !$sup) { | |
| 1386 | SUBSUPER: { | |
| 1387 | if ($matched eq "_" and $rest =~ /^\{/) { | |
| 1388 | $outline .= "<sub>"; | |
| 1389 | $sub = 1; if ($tt) { $tt++; } } | |
| 1390 | elsif ($matched eq "^" and $rest =~ /^\{/) { | |
| 1391 | $outline .= "<sup>"; | |
| 1392 | $sup = 1; if ($tt) { $tt++; } } | |
| 1393 | elsif ($matched eq "_" and $rest =~ /^[^\\]/) { | |
| 1394 | $outline .= "<sub>$&</sub>"; } | |
| 1395 | elsif ($matched eq "^" and $rest =~ /^[^\\]/) { | |
| 1396 | $outline .= "<sup>$&</sup>"; } | |
| 1397 | else { last SUBSUPER; } | |
| 1398 | $rest = $'; | |
| 1399 | next SPECIAL; | |
| 1400 | } | |
| 1401 | } | |
| 1402 | if ($matched =~ /[_^]/) { | |
| 1403 | $outline .= $matched; | |
| 1404 | next SPECIAL; | |
| 1405 | } | |
| 1406 | ||
| 1407 | # Braces are ignored, but must must be balanced inside `...'. | |
| 1408 | if ($matched eq "{") { | |
| 1409 | if ($tt) { $tt++; } | |
| 1410 | if ($sub) { $sub++; } | |
| 1411 | elsif ($sup) { $sup++; } | |
| 1412 | next SPECIAL; | |
| 1413 | } | |
| 1414 | if ($matched eq "}") { | |
| 1415 | if ($tt == 1) { | |
| 1416 | # print STDERR "o:$outline,m:$matched,r:$rest\n"; | |
| 1417 | die "Unbalanced braces in `...' ($outline$matched$rest)"; | |
| 1418 | } | |
| 1419 | if ($tt) { $tt--; } | |
| 1420 | if ($sub and !--$sub) { $outline .= "</sub>"; } | |
| 1421 | if ($sup and !--$sup) { $outline .= "</sup>"; } | |
| 1422 | next SPECIAL; | |
| 1423 | } | |
| 1424 | ||
| 1425 | # A tilde is a non-break space. | |
| 1426 | if ($matched eq "~") { | |
| 1427 | $outline .= " "; | |
| 1428 | next SPECIAL; | |
| 1429 | } | |
| 1430 | ||
| 1431 | # $ toggles maths mode. | |
| 1432 | if ($matched eq "\$") { | |
| 1433 | if ($rest =~ /^\$/) { | |
| 1434 | $rest = $'; | |
| 1435 | $endmath = "[\$][\$]"; | |
| 1436 | $endmathstring = "\$\$"; | |
| 1437 | } else { | |
| 1438 | $endmath = "[\$]"; | |
| 1439 | $endmathstring = "\$"; | |
| 1440 | } | |
| 1441 | if ($opt_t) { | |
| 1442 | if ($mode eq "normal") { | |
| 1443 | $tth= ""; | |
| 1444 | $mode = "tth"; | |
| 1445 | ||
| 1446 | while ($mode eq "tth") { | |
| 1447 | if ( $rest =~ /$endmath/ ) { | |
| 1448 | $tth .= $`; # the part scanned past | |
| 1449 | $rest = $'; | |
| 1450 | ||
| 1451 | # make a math mode string | |
| 1452 | $tth = "$endmathstring$tth$endmathstring"; | |
| 1453 | ||
| 1454 | # pass $tth to tth to convert to HTML | |
| 1455 | # and append the result | |
| 1456 | $outline .= tth_math_replace($tth); | |
| 1457 | $mode = "normal"; | |
| 1458 | } | |
| 1459 | else { | |
| 1460 | # we are in tth mode but the line has no terminating | |
| 1461 | # $ or $$: continue into next line | |
| 1462 | if ($rest =~ s/%$//) { # Mirror TeX behaviour when | |
| 1463 | $tth .= $rest; # line ends in a % ... | |
| 1464 | $rest = <IN>; # swallow whitespace at | |
| 1465 | $rest =~ s/^\s*//; # beginning of next line | |
| 1466 | } else { | |
| 1467 | $tth .= $rest." "; | |
| 1468 | $rest = <IN>; | |
| 1469 | } | |
| 1470 | chomp($rest); | |
| 1471 | } | |
| 1472 | } | |
| 1473 | ||
| 1474 | next SPECIAL; | |
| 1475 | } else { | |
| 1476 | die "math mode messup"; | |
| 1477 | } | |
| 1478 | } else { | |
| 1479 | $outline .= "<p>" if ($endmathstring eq "\$\$"); | |
| 1480 | if ($mode eq "maths") { | |
| 1481 | if ($sub) { die "Math mode ended during subscript ". | |
| 1482 | "($outline$matched$rest)"; } | |
| 1483 | elsif ($sup) { die "Math mode ended during superscript ". | |
| 1484 | "($outline$matched$rest)"; } | |
| 1485 | $mode = "normal"; | |
| 1486 | $outline .= "</var>"; | |
| 1487 | if ($tt) { $outline .= "<code>"; } | |
| 1488 | next SPECIAL; | |
| 1489 | } | |
| 1490 | $mode = "maths"; | |
| 1491 | if ($tt) { $outline .= "</code>"; } | |
| 1492 | $outline .= "<var>"; | |
| 1493 | next SPECIAL; | |
| 1494 | } | |
| 1495 | } | |
| 1496 | ||
| 1497 | # < > open and close italics. | |
| 1498 | if ($matched eq "<") { | |
| 1499 | if (not $it) { | |
| 1500 | if ($tt) { $outline .= "</code>"; } | |
| 1501 | $outline .= "<var>"; | |
| 1502 | $it = 1; | |
| 1503 | } else { | |
| 1504 | $outline .= "<"; | |
| 1505 | } | |
| 1506 | next SPECIAL; | |
| 1507 | } | |
| 1508 | if ($matched eq ">") { | |
| 1509 | if ($it) { | |
| 1510 | $outline .= "</var>"; | |
| 1511 | if ($tt) { $outline .= "<code>"; } | |
| 1512 | $it = 0; | |
| 1513 | } else { | |
| 1514 | $outline .= ">"; | |
| 1515 | } | |
| 1516 | next SPECIAL; | |
| 1517 | } | |
| 1518 | ||
| 1519 | # * in normal mode toggles bold-face. | |
| 1520 | if ($matched eq "*") { | |
| 1521 | if ($mode eq "normal" and not $tt) { | |
| 1522 | if ($bold) { | |
| 1523 | $outline .= "</strong>"; | |
| 1524 | $bold = 0; | |
| 1525 | } else { | |
| 1526 | $outline .= "<strong>"; | |
| 1527 | $bold = 1; | |
| 1528 | } | |
| 1529 | } else { | |
| 1530 | $outline .= "*"; | |
| 1531 | } | |
| 1532 | next SPECIAL; | |
| 1533 | } | |
| 1534 | ||
| 1535 | # ` and ' in normal mode control typewriter. | |
| 1536 | if ($matched eq "`") { | |
| 1537 | if ($tt) { | |
| 1538 | $outline .= "`"; | |
| 1539 | } elsif ( $rest =~ /^`/ ) { | |
| 1540 | $rest = $'; | |
| 1541 | $outline .= "``"; | |
| 1542 | } else { | |
| 1543 | $tt = 1; | |
| 1544 | $outline .= "<code>"; | |
| 1545 | } | |
| 1546 | next SPECIAL; | |
| 1547 | } | |
| 1548 | if ($matched eq "\'") { | |
| 1549 | if ($tt == 1) { | |
| 1550 | $outline .= "</code>"; | |
| 1551 | $tt = 0; | |
| 1552 | } else { | |
| 1553 | $outline .= "\'"; | |
| 1554 | } | |
| 1555 | next SPECIAL; | |
| 1556 | } | |
| 1557 | ||
| 1558 | # & signals a definition. We go back to start of line for the | |
| 1559 | # tag, and on to end of para for the definition. We do not | |
| 1560 | # merge adjacent definitions into the same list. | |
| 1561 | if ($matched eq "&") { | |
| 1562 | if ($inlist) { | |
| 1563 | $outline = "<dt>$outline<dd>"; # Sometimes we get an extra | |
| 1564 | } # <dt> we don't need ... | |
| 1565 | next SPECIAL; # but it has no effect :) | |
| 1566 | } | |
| 1567 | ||
| 1568 | # " starts a cross-reference. If it ends on the same input | |
| 1569 | # line then we can deal with it at once otherwise we set | |
| 1570 | # $inref. | |
| 1571 | if ($matched eq "\"") { | |
| 1572 | if ($tt) { | |
| 1573 | $outline .= "\""; | |
| 1574 | next SPECIAL; | |
| 1575 | } | |
| 1576 | if ($rest =~ /^$refchars+\"/o) { | |
| 1577 | $rest = $'; | |
| 1578 | chop($ref = $&); | |
| 1579 | $ref1 = name2fn($ref,0); | |
| 1580 | $ref2 = name2linktext($ref,0); | |
| 1581 | $outline .= "<a href=\"$ref1\">$ref2</a>"; | |
| 1582 | next SPECIAL; | |
| 1583 | } | |
| 1584 | if ($rest =~ /^$refchars*$/o) { | |
| 1585 | $ref = "$rest "; | |
| 1586 | $inref = 1; | |
| 1587 | print $outline; | |
| 1588 | next LINE; | |
| 1589 | } | |
| 1590 | die "Bad reference $rest at $_"; | |
| 1591 | } | |
| 1592 | ||
| 1593 | # Ignore from % to end of line, on-line browser does not do this. | |
| 1594 | if ($matched eq "%") { | |
| 1595 | print $outline."\n"; | |
| 1596 | next LINE; | |
| 1597 | } | |
| 1598 | ||
| 1599 | } # SPECIAL | |
| 1600 | print $outline.$rest.$endline."\n"; | |
| 1601 | if ($endline =~ /<\/code>/) { | |
| 1602 | $tt = 0; | |
| 1603 | } | |
| 1604 | $endline =""; | |
| 1605 | } # LINE | |
| 1606 | } | |
| 1607 | ||
| 1608 | ||
| 1609 | sub metaquote { | |
| 1610 | my $name = quotemeta $_[0]; | |
| 1611 | $name =~ s/\\ /\\s+/g; | |
| 1612 | return $name; | |
| 1613 | } | |
| 1614 | ||
| 1615 | sub startfile { | |
| 1616 | my $sec = $_[0]; | |
| 1617 | my ($num, $name, $re, $fname, $name1, $name2); | |
| 1618 | if ($sec->{secnum} == 0) { | |
| 1619 | $sec->{chapnum} = $chap->{number}; | |
| 1620 | $num = $chap->{number}; | |
| 1621 | $name = $chap->{name}; | |
| 1622 | $name1 = metaquote $name; | |
| 1623 | $re = "^\\\\(Chapter|PreliminaryChapter)\\{$name1\\}"; | |
| 1624 | } else { | |
| 1625 | $num = $sec->{chapnum} . "." .$sec->{secnum}; | |
| 1626 | $name = $sec->{name}; | |
| 1627 | $name1 = metaquote $name; | |
| 1628 | $re = "^\\\\Section\\{$name1\\}"; | |
| 1629 | } | |
| 1630 | $name2 = kanonize $name; | |
| 1631 | $fname = htm_fname($opt_c, | |
| 1632 | $sec->{chapnum}, $sec->{secnum}, $sec->{ssecnum}, ""); | |
| 1633 | ||
| 1634 | open ( OUT, ">${odir}${fname}" ) || die "Can't write to ${odir}${fname}"; | |
| 1635 | select OUT; | |
| 1636 | ||
| 1637 | print "<html><head><title>[$book] $num $name2</title></head>\n"; | |
| 1638 | print "<body text=\"\#000000\" bgcolor=\"\#ffffff\">\n"; | |
| 1639 | add_to_index($fname, $name, $sec); | |
| 1640 | navigation( ($opt_c) ? $chap->{sections}[0] : $sec ); | |
| 1641 | print "<h1>$num $name2</h1><p>\n"; | |
| 1642 | ||
| 1643 | return ($fname, $re); | |
| 1644 | } | |
| 1645 | ||
| 1646 | sub startsec { | |
| 1647 | my $sec = $_[0]; | |
| 1648 | my $snum = $sec->{secnum}; | |
| 1649 | my $name = $sec->{name}; | |
| 1650 | add_to_index(htm_fname($opt_c, $sec->{chapnum}, $snum, 0, ""), $name, $sec); | |
| 1651 | my $num = $sec->{chapnum} . "." .$snum; | |
| 1652 | $snum = "0" x (3 - length $snum) . $snum; | |
| 1653 | my $name1 = metaquote $name; | |
| 1654 | my $name2 = kanonize $name; | |
| 1655 | print "<h2><a name=\"SECT$snum\">$num $name2</a></h2>\n<p>"; | |
| 1656 | return "^\\\\Section\\{$name1\\}"; | |
| 1657 | } | |
| 1658 | ||
| 1659 | sub sectionlist { | |
| 1660 | my $chap = $_[0]; | |
| 1661 | my $sec; | |
| 1662 | print "<P>\n<H3>Sections</H3>\n<oL>\n"; | |
| 1663 | SUBSEC: for $sec (@{$chap->{sections}}) { | |
| 1664 | next SUBSEC if ($sec->{secnum} == 0); | |
| 1665 | my $link = htm_fname($opt_c, $sec->{chapnum}, $sec->{secnum}, 0, ""); | |
| 1666 | my $name2 = kanonize $sec->{name}; | |
| 1667 | print "<li> <A HREF=\"$link\">$name2</a>\n"; | |
| 1668 | } | |
| 1669 | print "</ol><p>\n"; | |
| 1670 | } | |
| 1671 | ||
| 1672 | # | |
| 1673 | # Basically the chapter file is read in one pass, using information previously | |
| 1674 | # read from the .toc file to fill in next and previous pointers and the like | |
| 1675 | # | |
| 1676 | ||
| 1677 | sub navigation { | |
| 1678 | my $sec = $_[0]; | |
| 1679 | my $chap = $sec->{chapter}; | |
| 1680 | my $cfname = htm_fname($opt_c, $sec->{chapnum}, 0, 0, ""); | |
| 1681 | if ($mainman == 1) { | |
| 1682 | print "[<a href=\"../index.htm\">Top</a>] " | |
| 1683 | } else { | |
| 1684 | if ($opt_f) { | |
| 1685 | print "[<a href=\"$opt_f\">Top</a>] " | |
| 1686 | } | |
| 1687 | }; | |
| 1688 | if ($sec->{secnum} == 0) { | |
| 1689 | print "[<a href = \"chapters.htm\">Up</a>] "; | |
| 1690 | if (tonum($chap->{number}) != 1) { | |
| 1691 | my $prev = htm_fname($opt_c, | |
| 1692 | $chapters[tonum($chap->{number}) - 1]{number}, | |
| 1693 | 0, 0, ""); | |
| 1694 | print "[<a href =\"$prev\">Previous</a>] "; | |
| 1695 | } | |
| 1696 | if (tonum($chap->{number}) != $#chapters) { | |
| 1697 | my $next = htm_fname($opt_c, | |
| 1698 | $chapters[tonum($chap->{number}) + 1]{number}, | |
| 1699 | 0, 0, ""); | |
| 1700 | print "[<a href =\"$next\">Next</a>] "; | |
| 1701 | } | |
| 1702 | } else { | |
| 1703 | print "[<a href = \"$cfname\">Up</a>] "; | |
| 1704 | if ($sec->{secnum} != 1) { | |
| 1705 | my $prev = htm_fname($opt_c, $chap->{number}, $sec->{secnum} - 1, | |
| 1706 | 0, ""); | |
| 1707 | print "[<a href =\"$prev\">Previous</a>] "; | |
| 1708 | } | |
| 1709 | if ($sec->{secnum} != $#{$chap->{sections}}) { | |
| 1710 | my $next = htm_fname($opt_c, $chap->{number}, $sec->{secnum} + 1, | |
| 1711 | 0, ""); | |
| 1712 | print "[<a href =\"$next\">Next</a>] "; | |
| 1713 | } elsif (tonum($chap->{number}) != $#chapters) { | |
| 1714 | my $next = htm_fname($opt_c, | |
| 1715 | $chapters[tonum($chap->{number}) + 1]{number}, | |
| 1716 | 0, 0, ""); | |
| 1717 | print "[<a href =\"$next\">Next</a>] "; | |
| 1718 | } | |
| 1719 | } | |
| 1720 | print "[<a href = \"theindex.htm\">Index</a>]\n"; | |
| 1721 | } | |
| 1722 | ||
| 1723 | ||
| 1724 | sub convert_chap { | |
| 1725 | my ($chap) = @_; | |
| 1726 | my ($re, $startre, $fname, $secline); | |
| 1727 | $indexcount = 0; | |
| 1728 | open (IN, "<$dir$chap->{file}.tex") | |
| 1729 | || die "Can't read $dir$chap->{file}.tex"; | |
| 1730 | $_ = <IN>; | |
| 1731 | ||
| 1732 | # loop, controlled by the list of sections that we expect | |
| 1733 | # will fail, possibly messily if this does not match reality | |
| 1734 | ||
| 1735 | # The call to startfile produces navigation + a chapter heading | |
| 1736 | if ($opt_c) { # each chapter in a single file | |
| 1737 | ($fname,$re) = startfile $chap->{sections}[0]; | |
| 1738 | } | |
| 1739 | ||
| 1740 | # note we *need* $sec to act globally in what follows! | |
| 1741 | SECT: for $sec (@{$chap->{sections}}) { | |
| 1742 | ||
| 1743 | # sort out what we are processing (chapter or section) | |
| 1744 | # produce the header of the Web page | |
| 1745 | ||
| 1746 | if ($opt_c) { | |
| 1747 | $re = startsec $sec unless ($sec->{secnum} == 0); | |
| 1748 | } else { | |
| 1749 | # The call to startfile produces navigation + a section heading | |
| 1750 | ($fname, $re) = startfile $sec; | |
| 1751 | # print STDERR "fname: $fname, re: $re\n"; | |
| 1752 | } | |
| 1753 | ($startre = $re) =~ s/(^[^\{]*\{).*/$1/; | |
| 1754 | ||
| 1755 | # | |
| 1756 | # Look for the \Chapter or \Section line | |
| 1757 | # | |
| 1758 | ||
| 1759 | while ( !/$startre/ ) { | |
| 1760 | unless (defined($_ = <IN>)) { | |
| 1761 | die "Missing chapter or section line matching $startre" }; | |
| 1762 | }; | |
| 1763 | ||
| 1764 | chomp; | |
| 1765 | $secline = $_; | |
| 1766 | while ( $secline !~ /\}/ ) { | |
| 1767 | unless (defined($_ = <IN>)) { | |
| 1768 | die "Missing chapter or section line matching $re" }; | |
| 1769 | chomp; | |
| 1770 | s/\%.*//; | |
| 1771 | $secline .= " $_"; | |
| 1772 | }; | |
| 1773 | ||
| 1774 | unless ($secline =~ /$re/) { | |
| 1775 | die "Missing chapter or section line matching $re" | |
| 1776 | }; | |
| 1777 | ||
| 1778 | # If this is the beginning of a chapter, we list its sections | |
| 1779 | if ($sec->{secnum} == 0) { | |
| 1780 | if (defined($chap->{sections}[1])) { | |
| 1781 | sectionlist $chap; | |
| 1782 | } else { | |
| 1783 | print STDERR "Warning: Chapter has no sections\n"; | |
| 1784 | } | |
| 1785 | } | |
| 1786 | ||
| 1787 | # Now we print the section body | |
| 1788 | convert_text($fname); | |
| 1789 | print "<p>\n"; | |
| 1790 | ||
| 1791 | # If it's one file per section ... add navigation etc. at end of file | |
| 1792 | unless ($opt_c) { | |
| 1793 | navigation $sec; | |
| 1794 | print $footer; | |
| 1795 | close OUT; | |
| 1796 | select STDOUT; | |
| 1797 | } | |
| 1798 | } | |
| 1799 | ||
| 1800 | # If it's one file per chapter ... add navigation etc. at end of file | |
| 1801 | if ($opt_c) { | |
| 1802 | navigation $chap->{sections}[0]; | |
| 1803 | print $footer; | |
| 1804 | close OUT; | |
| 1805 | select STDOUT; | |
| 1806 | } | |
| 1807 | close IN; | |
| 1808 | } | |
| 1809 | ||
| 1810 | ||
| 1811 | ||
| 1812 | sub chapters_page { | |
| 1813 | open (OUT, ">${odir}chapters.htm") | |
| 1814 | || die "Can't write to ${odir}chapters.htm"; | |
| 1815 | select OUT; | |
| 1816 | ||
| 1817 | print <<END | |
| 1818 | <html><head><title>$booktitle - Chapters</title></head> | |
| 1819 | <body text=\"\#000000\" bgcolor=\"\#ffffff\"> | |
| 1820 | <h1>$booktitle_body - Chapters</h1> | |
| 1821 | <ul> | |
| 1822 | <li><a href=\"theindex.htm\">Index</a> | |
| 1823 | </ul> | |
| 1824 | <ol> | |
| 1825 | END | |
| 1826 | ; | |
| 1827 | ||
| 1828 | CHAP: foreach $chap (@chapters) { | |
| 1829 | unless (defined $chap) { next CHAP}; | |
| 1830 | my $link = htm_fname($opt_c, $chap->{number}, 0, 0, ""); | |
| 1831 | my $name2 = kanonize $chap->{name}; | |
| 1832 | print "</ol><ol type=\"A\">\n" if ( $chap->{number} eq "A" ); | |
| 1833 | print "<li><a href=\"$link\">$name2</a>\n"; | |
| 1834 | } | |
| 1835 | ||
| 1836 | print <<END | |
| 1837 | </ol> | |
| 1838 | <ul> | |
| 1839 | <li><a href=\"biblio.htm\">References</a> | |
| 1840 | <li><a href=\"theindex.htm\">Index</a> | |
| 1841 | </ul><p> | |
| 1842 | END | |
| 1843 | ; | |
| 1844 | if ($mainman == 1) { | |
| 1845 | print "[<a href=\"../index.htm\">Top</a>]<p>" | |
| 1846 | } else { | |
| 1847 | if ($opt_f) { | |
| 1848 | print "[<a href=\"$opt_f\">Top</a>] " | |
| 1849 | } | |
| 1850 | }; | |
| 1851 | print $footer; | |
| 1852 | close OUT; | |
| 1853 | select STDOUT; | |
| 1854 | ||
| 1855 | # Touch the chapters file so that `make' recognizes the conversion | |
| 1856 | # has been done. | |
| 1857 | system "touch ${odir}chapters.htm"; | |
| 1858 | } | |
| 1859 | ||
| 1860 | sub caseless { lc($a) cmp lc ($b) or $a cmp $b } | |
| 1861 | ||
| 1862 | sub index_head { | |
| 1863 | my ($letter, @letters) = @_; | |
| 1864 | my ($bstb); | |
| 1865 | print <<END | |
| 1866 | <html><head><title>$booktitle - Index ${letter}</title></head> | |
| 1867 | <body text=\"\#000000\" bgcolor=\"\#ffffff\"> | |
| 1868 | <h1>$booktitle_body - Index ${letter}</h1> | |
| 1869 | <p> | |
| 1870 | END | |
| 1871 | ; | |
| 1872 | # print STDERR $letter, @letters, "\n"; | |
| 1873 | foreach $bstb (@letters) { | |
| 1874 | if ($opt_i) { | |
| 1875 | print "<a href=\"\#idx${bstb}\">$bstb</A>\n"; | |
| 1876 | } | |
| 1877 | elsif ($bstb eq "_") { | |
| 1878 | print "<a href=\"theindex.htm\">$bstb</A>\n"; | |
| 1879 | } | |
| 1880 | else { | |
| 1881 | print "<a href=\"indx${bstb}.htm\">$bstb</A>\n"; | |
| 1882 | } | |
| 1883 | } | |
| 1884 | } | |
| 1885 | ||
| 1886 | sub index_end { | |
| 1887 | print "</dl><p>\n"; | |
| 1888 | if ($mainman == 1) { | |
| 1889 | print "[<a href=\"../index.htm\">Top</a>] " | |
| 1890 | } else { | |
| 1891 | if ($opt_f) { | |
| 1892 | print "[<a href=\"$opt_f\">Top</a>] " | |
| 1893 | } | |
| 1894 | }; | |
| 1895 | print "[<a href=\"chapters.htm\">Up</a>]"; | |
| 1896 | print "<p>\n$footer"; | |
| 1897 | } | |
| 1898 | ||
| 1899 | sub index_page { | |
| 1900 | my ($ent, $ref, $letter, $bstb, $thisletter, @entries, %letters, @letters); | |
| 1901 | %letters = $opt_i ? () | |
| 1902 | : ("_" => ""); # With multiple indices, the "_" | |
| 1903 | # index is theindex.htm | |
| 1904 | foreach $ent (keys %index) { | |
| 1905 | $bstb = uc(substr($ent,0,1)); | |
| 1906 | if ($bstb lt "A" or $bstb gt "Z") {$bstb = "_";} | |
| 1907 | $letters{$bstb} = ""; | |
| 1908 | } | |
| 1909 | @letters = sort caseless keys %letters; | |
| 1910 | ||
| 1911 | $letter = $opt_i ? "" : "_"; | |
| 1912 | open (OUT, ">${odir}theindex.htm") | |
| 1913 | || die "Can't write to ${odir}theindex.htm"; | |
| 1914 | select OUT; | |
| 1915 | index_head($letter, @letters); | |
| 1916 | ||
| 1917 | ENTRY: foreach $ent (sort caseless keys %index) { | |
| 1918 | $thisletter = uc(substr($ent,0,1)); | |
| 1919 | if ($thisletter lt "A" or $thisletter gt "Z") {$thisletter = "_";} | |
| 1920 | if ($letter eq "") { # Only happens first time round for $opt_i | |
| 1921 | $letter = $thisletter; | |
| 1922 | print "<H2><A NAME=\"idx${letter}\">$letter</A></H2>\n<dl>\n"; | |
| 1923 | } | |
| 1924 | elsif ($letter ne $thisletter) { | |
| 1925 | $letter = $thisletter; | |
| 1926 | if ($opt_i) { | |
| 1927 | print "</dl><p>\n"; | |
| 1928 | print "<H2><A NAME=\"idx${letter}\">$letter</A></H2>\n<dl>\n"; | |
| 1929 | } | |
| 1930 | else { | |
| 1931 | index_end; | |
| 1932 | close OUT; | |
| 1933 | select STDOUT; | |
| 1934 | open (OUT, ">${odir}indx${letter}.htm") | |
| 1935 | || die "Can't write to ${odir}indx${letter}.htm"; | |
| 1936 | select OUT; | |
| 1937 | index_head($letter, @letters); | |
| 1938 | } | |
| 1939 | } | |
| 1940 | $ent1 = $ent; | |
| 1941 | $ent1 =~ s/!/, /g; | |
| 1942 | $ent1 =~ s/[{}]//g; | |
| 1943 | print "<dt>".kanonize $ent1." "; | |
| 1944 | for $ref (@{$index{$ent}}) { | |
| 1945 | print "<a href=\"$ref->[0]\">$ref->[1]</a> "; | |
| 1946 | } | |
| 1947 | print "\n"; | |
| 1948 | } | |
| 1949 | index_end; | |
| 1950 | close OUT; | |
| 1951 | select STDOUT; | |
| 1952 | } | |
| 1953 | ||
| 1954 | sub biblio_page { | |
| 1955 | my $infile = "${dir}manual.bbl"; | |
| 1956 | my $outfile = "${odir}biblio.htm"; | |
| 1957 | my $macro; | |
| 1958 | open (OUT, ">${outfile}") || die "Can't write to ${outfile}"; | |
| 1959 | select OUT; | |
| 1960 | ||
| 1961 | print <<END | |
| 1962 | <html><head><title>$booktitle - References</title></head> | |
| 1963 | <body text=\"\#000000\" bgcolor=\"\#ffffff\"> | |
| 1964 | <h1>$booktitle_body - References</h1><dl> | |
| 1965 | END | |
| 1966 | ; | |
| 1967 | ||
| 1968 | if (-f $infile and -r $infile) { | |
| 1969 | open IN, "<$infile"; | |
| 1970 | my ($brace,$embrace) = (0,-1); | |
| 1971 | while (<IN>) { | |
| 1972 | chomp; | |
| 1973 | my $outline = ""; | |
| 1974 | if (/newcommand/ || /thebibliography/) { } | |
| 1975 | elsif (/^\\bibitem\[[^\]]+\]\{([^\}]+)\}/) { | |
| 1976 | print "<dt><a name=\"$1\"><b>[$1]</b></a><dd>\n"; | |
| 1977 | } else { | |
| 1978 | my $line = $_; | |
| 1979 | if ($line =~ /^\s*\\newblock/) { $outline .= "<br>"; | |
| 1980 | $line = $'; } | |
| 1981 | while ($line =~ /[\${}<>~&\\]/) { | |
| 1982 | $outline .= $`; | |
| 1983 | $matched = $&; | |
| 1984 | $line = $'; | |
| 1985 | if ($opt_t and $matched eq "\$" and $line =~ /([^\$]*\$)/) { | |
| 1986 | # if we are using the -t option and we have | |
| 1987 | # detected a *simple* maths formula $...$ pass it | |
| 1988 | # off directly to tth_math_replace. Bibliographies | |
| 1989 | # should only have very simple maths formulae. If | |
| 1990 | # it's broken over a line, we won't detect it. | |
| 1991 | $matched .= $&; | |
| 1992 | $outline .= tth_math_replace($matched); | |
| 1993 | $line = $'; | |
| 1994 | } elsif ($matched eq "\{") { | |
| 1995 | if ($line =~ /^\\(em|it)\s*/) { $embrace = $brace; | |
| 1996 | $outline .= "<em>"; | |
| 1997 | $line = $'; } | |
| 1998 | $brace++; | |
| 1999 | } elsif ($matched eq "\}") { | |
| 2000 | $brace--; | |
| 2001 | if ($brace == -1 ) { | |
| 2002 | die "Unbalanced braces in bbl file ". | |
| 2003 | "($outline$matched$line"; | |
| 2004 | } elsif ($brace == $embrace) { $outline .= "</em>"; | |
| 2005 | $embrace = -1; } | |
| 2006 | } elsif ($matched eq "\\") { | |
| 2007 | if ($line =~ /^cite\{([^\}]*)\}/) { | |
| 2008 | $outline .= "<a href=\"#$1\"><cite>$1</cite></a>"; | |
| 2009 | $line = $'; | |
| 2010 | } else { | |
| 2011 | ($line, $macro) = macro_replace($line); | |
| 2012 | $outline .= $macro; | |
| 2013 | } | |
| 2014 | } elsif ($matched eq "~" ) { | |
| 2015 | $outline .= " "; | |
| 2016 | } elsif ($matched ne "\$") { | |
| 2017 | $outline .= html_literal $matched; | |
| 2018 | } | |
| 2019 | } | |
| 2020 | print "$outline$line\n"; | |
| 2021 | } | |
| 2022 | } | |
| 2023 | } else { | |
| 2024 | print STDERR "Warning: did not find a .bbl file ... ok?\n"; | |
| 2025 | } | |
| 2026 | print "</dl><p>\n"; | |
| 2027 | if ($mainman == 1) { | |
| 2028 | print "[<a href=\"../index.htm\">Top</a>] " | |
| 2029 | } else { | |
| 2030 | if ($opt_f) { | |
| 2031 | print "[<a href=\"$opt_f\">Top</a>] " | |
| 2032 | } | |
| 2033 | }; | |
| 2034 | print "[<a href=\"chapters.htm\">Up</a>]"; | |
| 2035 | print "<p>\n$footer\n"; | |
| 2036 | close OUT; | |
| 2037 | select STDOUT; | |
| 2038 | } | |
| 2039 | ||
| 2040 | # | |
| 2041 | # Main program starts here | |
| 2042 | # | |
| 2043 | # Process option and sort out input and output directories | |
| 2044 | # | |
| 2045 | ||
| 2046 | getopts('csitun:f:'); | |
| 2047 | ||
| 2048 | if (!$opt_c) {$opt_c = 0;} # just to ensure it is not empty | |
| 2049 | ||
| 2050 | chomp($dir = shift @ARGV); | |
| 2051 | if (substr($dir,0,1) ne "/") { | |
| 2052 | $dir = `pwd` . "/" . $dir; | |
| 2053 | $dir =~ s/\n//; | |
| 2054 | } | |
| 2055 | if (substr($dir,-1) ne "/") { | |
| 2056 | $dir .= "/"; | |
| 2057 | } | |
| 2058 | unless (-d $dir and -r $dir) { | |
| 2059 | die "Can't use input directory $dir"; | |
| 2060 | } | |
| 2061 | ||
| 2062 | if ($opt_t) { | |
| 2063 | my ($whichtth) = `which tth`; | |
| 2064 | chomp($whichtth); | |
| 2065 | if ($whichtth !~ m+/tth$+) { | |
| 2066 | print STDERR "!! tth: not in path.\n$whichtth\n", | |
| 2067 | "... Maths formulae will vanish!", | |
| 2068 | " Install tth or avoid -t option.\n"; | |
| 2069 | } | |
| 2070 | $tthbin="tth"; | |
| 2071 | } | |
| 2072 | ||
| 2073 | if ($opt_u) { | |
| 2074 | my ($whichtth) = `which tth`; | |
| 2075 | chomp($whichtth); | |
| 2076 | if ($whichtth !~ m+/tth$+) { | |
| 2077 | print STDERR "!! tth: not in path.\n$whichtth\n", | |
| 2078 | "... Maths formulae will vanish!", | |
| 2079 | " Install tth or avoid -t option.\n"; | |
| 2080 | } | |
| 2081 | $tthbin="tth -u2"; | |
| 2082 | } | |
| 2083 | ||
| 2084 | if ($opt_n) { | |
| 2085 | # get book title | |
| 2086 | $book=$opt_n; | |
| 2087 | #$booktitle = "$opt_n : a GAP example"; | |
| 2088 | $booktitle = "$opt_n : a GAP 4 package"; | |
| 2089 | $booktitle_body = booktitle_body($booktitle, ("GAP", $opt_n)); | |
| 2090 | $mainman=0; | |
| 2091 | $footer = "<P>\n<address>$opt_n manual<br>" . | |
| 2092 | `date +"%B %Y"` . "</address></body></html>"; | |
| 2093 | #print "c: $opt_c \n"; | |
| 2094 | } else { | |
| 2095 | if ($opt_f) { | |
| 2096 | die "option -f can only be used together with -n "; | |
| 2097 | } | |
| 2098 | if ($dir =~ /\/([^\/]+)\/$/) { | |
| 2099 | $book = $1; | |
| 2100 | } else { | |
| 2101 | die "Can't find basename of $dir"; | |
| 2102 | } | |
| 2103 | if ($book eq "tut") { | |
| 2104 | $booktitle = "The GAP 4 Tutorial"; | |
| 2105 | } elsif ($book eq "ref") { | |
| 2106 | $booktitle = "The GAP 4 Reference Manual"; | |
| 2107 | } elsif ($book eq "changes") { | |
| 2108 | $booktitle = "GAP - Changes from Earlier Versions"; | |
| 2109 | } else { | |
| 2110 | die "Invalid book, must be tut, ref or changes"; | |
| 2111 | } | |
| 2112 | $booktitle_body = booktitle_body($booktitle, "GAP"); | |
| 2113 | $mainman=1; | |
| 2114 | } | |
| 2115 | ||
| 2116 | if ($#ARGV != -1) { | |
| 2117 | chomp($odir=shift @ARGV); | |
| 2118 | } else { | |
| 2119 | $odir = ""; | |
| 2120 | } | |
| 2121 | if (substr($odir,0,1) ne "/") { | |
| 2122 | $odir = `pwd` . "/" . $odir; | |
| 2123 | $odir =~ s/\n//; | |
| 2124 | } | |
| 2125 | if (substr($odir,-1) ne "/") { | |
| 2126 | $odir .= "/"; | |
| 2127 | } | |
| 2128 | unless (-d $odir and -w $odir) { | |
| 2129 | die "Can't use output directory $odir"; | |
| 2130 | } | |
| 2131 | print "Reading input from $dir\n" unless ($opt_s); | |
| 2132 | print "Creating output in $odir\n" unless ($opt_s); | |
| 2133 | ||
| 2134 | if ($opt_t || $opt_u) { | |
| 2135 | # create macro file for our expressions and macros not known to tth in TeX | |
| 2136 | # mode. | |
| 2137 | $opt_t = tth_version; | |
| 2138 | print STDERR "Using TtH $opt_t to translate maths formulae.\n"; | |
| 2139 | $opt_t =~ s/Version //; | |
| 2140 | open (TTHIN, ">tthmacros.tex") || die "Can't create tthmacros.tex"; | |
| 2141 | print TTHIN "\\def\\Q{{\\bf Q}}\\def\\Z{{\\bf Z}}\\def\\N{{\\bf N}}\n", | |
| 2142 | "\\def\\R{{\\bf R}}\\def\\F{{\\bf F}}\n"; | |
| 2143 | print TTHIN "\\def\\calR{{\\cal R}}\\def\\I{{\\cal I}}\n", | |
| 2144 | "\\def\\frac#1#2{{{#1}\\over{#2}}}\\def\\colon{:}\n", | |
| 2145 | "\\def\\longmapsto{\\mapsto}\\def\\lneqq{<}\n", | |
| 2146 | "\\def\\hookrightarrow{\\rightarrow}\n"; | |
| 2147 | if ($opt_t < 2.52) { | |
| 2148 | # We work-around most of the deficiencies of versions of TtH | |
| 2149 | # prior to Version 2.52 ... but can't easily fix the lack of | |
| 2150 | # proper treatment of \not. | |
| 2151 | print STDERR | |
| 2152 | "Your version of TtH does not know many TeX commands.\n", | |
| 2153 | "It is recommended that you upgrade to the latest version from\n", | |
| 2154 | " http://hutchinson.belmont.ma.us/tth/tth-noncom/download.html\n"; | |
| 2155 | print TTHIN "\\def\\mid{ | }\\def\\lbrack{[}\\def\\rbrack{]}\n", | |
| 2156 | "\\def\\gets{\\leftarrow}\\def\\land{\\wedge}\n"; | |
| 2157 | } | |
| 2158 | close TTHIN; | |
| 2159 | } | |
| 2160 | ||
| 2161 | getchaps; | |
| 2162 | print "Processed TOC files\n" unless ($opt_s); | |
| 2163 | ||
| 2164 | open (TEX, "<${dir}manual.tex") || die "Can't open ${dir}manual.tex"; | |
| 2165 | getlabs $dir; | |
| 2166 | while (<TEX>) { | |
| 2167 | if (/\\UseReferences\{\/([^}]*)}/) { | |
| 2168 | getlabs "/$1/"; | |
| 2169 | } elsif (/\\UseReferences\{([^}]*)}/) { | |
| 2170 | getlabs "$dir$1/"; | |
| 2171 | } elsif (/\\UseGapDocReferences\{\/([^}]*)}/) { | |
| 2172 | getlabs "/$1/"; | |
| 2173 | } elsif (/\\UseGapDocReferences\{([^}]*)}/) { | |
| 2174 | getlabs "$dir$1/"; | |
| 2175 | # ($gapdocbook = $1) =~ s?.*/([^/]*)/doc?$1?; | |
| 2176 | # $gapdocbooks{$gapdocbook} = 1; | |
| 2177 | # print STDERR "GapDoc books: ", keys(%gapdocbooks), "\n"; | |
| 2178 | } elsif (/\\Package\{([^}]*)}/) { | |
| 2179 | $sharepkg .= "|$1"; | |
| 2180 | } | |
| 2181 | } | |
| 2182 | print "Processed LAB files\n" unless ($opt_s); | |
| 2183 | ||
| 2184 | # | |
| 2185 | # OK go to work | |
| 2186 | # | |
| 2187 | ||
| 2188 | CHAP: foreach $chap (@chapters) { | |
| 2189 | unless (defined $chap) { | |
| 2190 | next CHAP; | |
| 2191 | } | |
| 2192 | print "$chap->{number}. $chap->{name} ... $chap->{file}.tex\n" | |
| 2193 | unless ($opt_s); | |
| 2194 | convert_chap $chap; | |
| 2195 | } | |
| 2196 | ||
| 2197 | print "and the chapters page\n" unless ($opt_s); | |
| 2198 | chapters_page; | |
| 2199 | print "and the index pages\n" unless ($opt_s); | |
| 2200 | index_page; | |
| 2201 | print "and the references\n" unless ($opt_s); | |
| 2202 | biblio_page; | |
| 2203 | ||
| 2204 | if ($opt_t || $opt_u ) { | |
| 2205 | # remove the tth stuff | |
| 2206 | unlink 'tthin','tthout','tthmacros.tex'; | |
| 2207 | } | |
| 2208 | ||
| 2209 | print "done\n" unless ($opt_s); | |
| 2210 | ############################################################################# |
| 0 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 1 | %% | |
| 2 | %A gapmacro.tex GAP manual Frank Celler | |
| 3 | %A Heiko Theissen | |
| 4 | %A Alexander Hulpke | |
| 5 | %A Burkhard Höfling | |
| 6 | %% | |
| 7 | %% | |
| 8 | %% DO NOT RELY ON MACRO DEFINITIONS IN THIS FILE! | |
| 9 | %% The official definition of the manual style is to be found in the file | |
| 10 | %% `gapmacrodoc.tex'. | |
| 11 | %% | |
| 12 | %% The following macros are defined in this file. | |
| 13 | %% | |
| 14 | %% `text' set text in typewriter style (use `\<' instead of `<') | |
| 15 | %% <text> set text in italics (use $\<$ instead of $<$ for less than) | |
| 16 | %% *text* set text in emphasized style (i.e. slanted) | |
| 17 | %% $a.b$ same as $a \cdot b$ (use $\.$ instead of $.$ for full stop) | |
| 18 | %% "ref" refer to a label (like "function!for category") | |
| 19 | %% \pif sets a single ' | |
| 20 | %% \cite{.} make a citation | |
| 21 | %% \index{.} \indextt{.} make index entry (\indextt in typewriter style) | |
| 22 | %% | |
| 23 | %% \beginitems produce itemized texts with 3pc hanging indentation | |
| 24 | %% item & text | |
| 25 | %% | |
| 26 | %% item & text ... | |
| 27 | %% \enditems | |
| 28 | %% | |
| 29 | %% \begintt verbatim text in typewriter style | |
| 30 | %% verbatim material | |
| 31 | %% \endtt | |
| 32 | %% \beginexample verbatim text in typewriter style | |
| 33 | %% verbatim material | |
| 34 | %% \endexample | |
| 35 | %% | |
| 36 | %% \Input{file} includes file `file.tex' | |
| 37 | %% \Chapter{title} followed by a blank line | |
| 38 | %% \Section{title} followed by a blank line | |
| 39 | %% make chapter or section title. Automatically generates table of | |
| 40 | %% contents. \null after \Section{...} inhibits indexing. | |
| 41 | %% \>function( arguments )!{ index subentry } | |
| 42 | %% \>`a binop b'{binary operation}!{ index subentry } | |
| 43 | %% make a heading for a subsection explaining a function or a binary | |
| 44 | %% operation. This automatically generates a label and an index entry | |
| 45 | %% (with optional subentry). | |
| 46 | %% \){\fmark ...} | |
| 47 | %% the same without label and index entry | |
| 48 | %% | |
| 49 | %% \URL{url} | |
| 50 | %% \Mailto{} | |
| 51 | %% | |
| 52 | %% \BeginningOfBook | |
| 53 | %% \FrontMatter, \Chapters, \Appendices, \EndMatter parts of the book | |
| 54 | %% \Bibliography, \Index, \TableOfContents make these chapters (w/o head) | |
| 55 | %% \EndOfBook | |
| 56 | %% | |
| 57 | %% The following macros can be used just after inputting gapmacro.tex to control | |
| 58 | %% the layout. | |
| 59 | %% \casesensitivetrue makes labels case sensitive (this is still experimental | |
| 60 | %% and not currently supported by the html converter) | |
| 61 | %% \casesensitivefalse & (default) labels are case insensitive | |
| 62 | %% | |
| 63 | %% \addlinks (default) This inserts pdf links within the document, so | |
| 64 | %% that you can click on a reference or citation. This will only work | |
| 65 | %% with pdftex, otherwise this has no effect. | |
| 66 | %% | |
| 67 | %% \nolinks This switches off additional pdf links within the document. | |
| 68 | %% | |
| 69 | %% \citebookstrue References to external books will be | |
| 70 | %% "GAP Reference Manual, 2.7.12" instead of just "2.7.12", similarly | |
| 71 | %% for the GAP tutorial. If you cite other books, you have to define | |
| 72 | %% macros \xxxManual which must expand to the text which you want to | |
| 73 | %% be inserted before the number for package xxx (lower case). | |
| 74 | %% \citebooksfalse (default) just print the number | |
| 75 | %% | |
| 76 | %% \usepsfonts (default) use the standard Postscript fonts for typesetting | |
| 77 | %% \usecmfonts use the TeX standard fonts | |
| 78 | %% | |
| 79 | %% \biblitemfalse (default) In the bibliography, print abbreviations for | |
| 80 | %% papers right-aligned (as in gapmacro.tex) | |
| 81 | %% \biblitemtrue print abbreviations left-aligned | |
| 82 | %% \bibindent (default: 3 pc) indentation used in the bibliography - | |
| 83 | %% depending | |
| 84 | %% on the abbreviations you use, you may need more (this is not very | |
| 85 | %% obvious if you use \biblitemfalse because long abbreviations will | |
| 86 | %% protrude into the left margin only, but will cause overfull hboxes | |
| 87 | %% when using \biblitemtrue | |
| 88 | ||
| 89 | \input amssym.tex | |
| 90 | ||
| 91 | \catcode`@=11 | |
| 92 | ||
| 93 | % Page dimensions and double column output. | |
| 94 | \hsize 39pc | |
| 95 | \vsize 52pc | |
| 96 | ||
| 97 | \gdef\nolinks{ | |
| 98 | \gdef\nameddest##1{}% | |
| 99 | \gdef\startlink##1{}% | |
| 100 | \gdef\endlink{}% | |
| 101 | } | |
| 102 | ||
| 103 | \gdef\addlinks{ | |
| 104 | \gdef\nameddest##1{% | |
| 105 | \ifx\debuglabels\undefined\else\immediate\write16{nameddest ##1 defined}\fi | |
| 106 | \ifvmode \pdfdest name{##1} xyz% | |
| 107 | \else\vbox to 0pt{\vss\pdfdest name{##1} xyz% | |
| 108 | \vskip\baselineskip}\fi}% | |
| 109 | \gdef\startlink##1{\begingroup{% | |
| 110 | \ifx\debuglabels\undefined\else\immediate\write16{link ##1 inserted}\fi | |
| 111 | \pdfstartlink attr{/Border [0 0 0]} goto name{##1}}\pdfliteral{\linkcolor}}% | |
| 112 | \gdef\endlink{\pdfliteral{0 0 0 rg}\pdfendlink\endgroup}% | |
| 113 | } | |
| 114 | ||
| 115 | % do we run pdftex? | |
| 116 | \ifx\pdfdest\undefined | |
| 117 | \immediate\write16{Running TeX} | |
| 118 | % no: define dummy bookmarking functions | |
| 119 | \global\def\setbookmarkind#1#2{} | |
| 120 | \global\def\setbookmark#1#2{} | |
| 121 | \global\def\indexbookmark#1#2{} | |
| 122 | \nolinks | |
| 123 | \let\addlinks\relax | |
| 124 | \else | |
| 125 | \def\linkcolor{0 0.1 0.6 rg} | |
| 126 | \immediate\write16{Running PDFTeX} | |
| 127 | % yes: define macros to do pdf stuff and set some parameters | |
| 128 | \global\def\setbookmarkind#1#2{% | |
| 129 | \setindent{\chapterlen{\the\chapno}} | |
| 130 | \pdfoutline goto name{#1} count -\indentno {#2}} | |
| 131 | \global\def\setbookmark#1#2{% | |
| 132 | \setindent{\chapterlen{\the\chapno}} | |
| 133 | \pdfoutline goto name{#1} count 0 {#2}} | |
| 134 | % special treatment for the index to get proper indention | |
| 135 | \global\def\indexbookmark#1#2{% | |
| 136 | \pdfoutline goto name{#1} count -27 {#2}} | |
| 137 | \addlinks | |
| 138 | \pdfinfo{ | |
| 139 | /Subject (GAP Manual) | |
| 140 | /Author (The GAP Group) | |
| 141 | } | |
| 142 | \pdfcatalog{ | |
| 143 | /URI (https://www.gap-system.org) | |
| 144 | % /PageMode /UseOutlines} | |
| 145 | /PageMode /UseNone} | |
| 146 | \pdfcompresslevel 9 | |
| 147 | \fi | |
| 148 | ||
| 149 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 150 | % | |
| 151 | % Generic double column output. | |
| 152 | % | |
| 153 | % Modified from a routine written by Donald Knuth (The TeXBook, App. E) | |
| 154 | % | |
| 155 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 156 | % | |
| 157 | % The user may modify the following to his tastes: | |
| 158 | % | |
| 159 | % \pagewidth vertical length of page. | |
| 160 | % \pageheight horizontal width of page. | |
| 161 | % \colwidth column width | |
| 162 | % \separator macro to generate column separator. Default is nothing. | |
| 163 | % \rulesep sets it to \vrule. \norulesep doesn't. | |
| 164 | % \makepage default is what is contained in plain. | |
| 165 | % Create and initialize new dimensions. | |
| 166 | \newdimen\pagewidth \newdimen\pageheight \newdimen\colwidth | |
| 167 | \pagewidth=\hsize \pageheight=\vsize \colwidth=3.2truein | |
| 168 | ||
| 169 | \def\draft{\hsize 42pc\vsize 63pc\pagewidth=\hsize \pageheight=\vsize} | |
| 170 | ||
| 171 | \def\pif{\char39} | |
| 172 | ||
| 173 | \def\tron{\tracingmacros 1\tracingcommands 1\tracingonline 1} | |
| 174 | ||
| 175 | % This routine is used by \output ; this is different from | |
| 176 | % the one found in App. E. | |
| 177 | \def\onepageout#1{{\setbox255=\vbox{#1} | |
| 178 | \hsize=\pagewidth \vsize=\pageheight \plainoutput}} | |
| 179 | \def\normaloutput{\onepageout{\unvbox255}} | |
| 180 | \maxdeadcycles=100 % \output is called quite often | |
| 181 | ||
| 182 | \output={\normaloutput} | |
| 183 | \newbox\partialpage \newdimen\origvsize \newif\ifrigid | |
| 184 | \def\begindoublecolumns{\global\origvsize=\vsize \begingroup | |
| 185 | \output={\global\setbox\partialpage=\vbox{\unvbox255\kern0pt}}\eject | |
| 186 | \output={\doublecolumnout} \hsize=\colwidth \dimen@=\pageheight | |
| 187 | \advance\dimen@ by-\ht\partialpage \multiply\dimen@ by2 | |
| 188 | \ifdim\dimen@<2\baselineskip \dimen@=2\baselineskip\fi | |
| 189 | \vsize=\dimen@} | |
| 190 | \def\enddoublecolumns{\output={\balancecolumns}\eject | |
| 191 | \endgroup \global\vsize=\origvsize \pagegoal=\vsize} | |
| 192 | \def\doublecolumnout{\splittopskip=\topskip \splitmaxdepth=\maxdepth | |
| 193 | \setbox0=\vsplit255 to.46\vsize \setbox2=\vsplit255 to.46\vsize | |
| 194 | %\setbox0=\vbox{A\unvbox0B\vfill}\setbox2=\vbox{C\unvbox2D\vfill}% | |
| 195 | \onepageout\pagesofar \global\vsize=2\pageheight | |
| 196 | \unvbox255 \penalty\outputpenalty} | |
| 197 | \def\pagesofar{\unvbox\partialpage | |
| 198 | \wd0=\hsize \wd2=\hsize | |
| 199 | %\hbox to\pagewidth{\box0\hfil\separator\hfil\box2}} | |
| 200 | \hbox to\pagewidth{\valign{##\vfill\cr% | |
| 201 | \vbox{\unvbox0}\cr\noalign{\hfil\separator\hfil}\vbox{\unvbox2}\cr}}} | |
| 202 | \def\norulesep{\let\separator=\relax} | |
| 203 | \def\rulesep{\let\separator=\vrule} | |
| 204 | \let\separator=\relax | |
| 205 | \def\balancecolumns{\setbox0=\vbox{\unvbox255} \dimen@=\ht0 | |
| 206 | \advance\dimen@ by\topskip \advance\dimen@ by-\baselineskip | |
| 207 | \divide\dimen@ by2 \splittopskip=\topskip | |
| 208 | {\vbadness=10000 \loop \global\setbox3=\copy0 | |
| 209 | \global\setbox1=\vsplit3 to\dimen@ | |
| 210 | \ifdim\ht3>\dimen@ \global\advance\dimen@ by1pt \repeat} | |
| 211 | \ifrigid | |
| 212 | \setbox0=\vtop{\unvbox1} | |
| 213 | \setbox2=\vtop{\unvbox3} | |
| 214 | \else | |
| 215 | \setbox0=\vbox to\dimen@{\unvbox1} | |
| 216 | \setbox2=\vbox to\dimen@{\dimen2=\dp3 \unvbox3\kern-\dimen2 \vfil} | |
| 217 | \fi | |
| 218 | \global\vsize=\origvsize \pagesofar} | |
| 219 | ||
| 220 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 221 | ||
| 222 | \colwidth 19pc | |
| 223 | \newdimen\manindent \manindent 3pc | |
| 224 | \newdimen\smallmanindent \smallmanindent 1pc | |
| 225 | \parskip 1ex plus 0.5ex minus 0.5ex | |
| 226 | \parindent 0pt | |
| 227 | ||
| 228 | \outer\def\usepsfonts{% | |
| 229 | % change standard TeX fonts, from plain.tex | |
| 230 | \font\tenrm=ptmr7t at 10pt % roman text | |
| 231 | \font\sevenrm=ptmr7t at 7pt | |
| 232 | \font\fiverm=ptmr7t at 5pt | |
| 233 | \font\tenr=zptmcm7t at 10pt % math roman | |
| 234 | \font\sevenr=zptmcm7t at 7pt | |
| 235 | \font\fiver=zptmcm7t at 5pt | |
| 236 | \font\teni=zptmcm7m at 10pt % math italic | |
| 237 | \font\seveni=zptmcm7m at 7pt | |
| 238 | \font\fivei=zptmcm7m at 5pt | |
| 239 | \font\tensy=zptmcm7y at 10pt % math symbols | |
| 240 | \font\sevensy=zptmcm7y at 7pt | |
| 241 | \font\fivesy=zptmcm7y at 5pt | |
| 242 | \font\tenex=zptmcm7v at 10pt % math extension | |
| 243 | \font\tenbf=ptmb7t at 10pt % boldface extended | |
| 244 | \font\sevenbf=ptmb7t at 7pt | |
| 245 | \font\fivebf=ptmb7t at 5pt | |
| 246 | % additonal fonts needed by gapmacro.tex | |
| 247 | \font\tentt=cmtt10 % typewriter | |
| 248 | \font\tensl=ptmro7t at 10pt | |
| 249 | \font\tenit=ptmri7t at 10pt % text italic | |
| 250 | % Additional fonts needed by gapmacro.tex | |
| 251 | \font\inchhigh=phvb7t at 96pt | |
| 252 | \font\titlefont=phvb7t at 36pt | |
| 253 | \font\subtitlefont=phvb7t at 20pt | |
| 254 | \font\secfont=phvb7t at 13pt | |
| 255 | \font\sf=phvr7t at 10 pt | |
| 256 | \font\bsf=phvb7t at 10 pt | |
| 257 | \font\smallrom=ptmr7t at 8pt | |
| 258 | \font\sevenit=ptmri7t at 7pt | |
| 259 | \font\fiveit=ptmri7t at 5pt | |
| 260 | \inst@allfonts | |
| 261 | } | |
| 262 | \outer\def\usecmfonts{ | |
| 263 | % standard TeX fonts, from plain.tex | |
| 264 | \font\tenrm=cmr10 % roman text | |
| 265 | \font\sevenrm=cmr7 | |
| 266 | \font\fiverm=cmr5 | |
| 267 | \font\tenr=cmr10 % math roman | |
| 268 | \font\sevenr=cmr7 | |
| 269 | \font\fiver=cmr5 | |
| 270 | \font\teni=cmmi10 % math italic | |
| 271 | \font\seveni=cmmi7 | |
| 272 | \font\fivei=cmmi5 | |
| 273 | \font\tensy=cmsy10 % math symbols | |
| 274 | \font\sevensy=cmsy7 | |
| 275 | \font\fivesy=cmsy5 | |
| 276 | \font\tenex=cmex10 % math extension | |
| 277 | \font\tenbf=cmbx10 % boldface extended | |
| 278 | \font\sevenbf=cmbx7 | |
| 279 | \font\fivebf=cmbx5 | |
| 280 | \font\tentt=cmtt10 % typewriter | |
| 281 | \font\tensl=cmsl10 % slanted roman | |
| 282 | \font\tenit=cmti10 % text italic | |
| 283 | % Additional fonts needed by gapmacro.tex | |
| 284 | \font\inchhigh=cminch | |
| 285 | \font\titlefont=cmssdc10 at 40pt | |
| 286 | \font\subtitlefont=cmssdc10 at 24pt | |
| 287 | \font\secfont=cmssdc10 at 14pt | |
| 288 | \font\sf=cmss10 | |
| 289 | \font\bsf=cmssdc10 | |
| 290 | \font\smallrom=cmr8 | |
| 291 | \font\sevenit=cmti10 at 7pt | |
| 292 | \font\fiveit=cmti10 at 5pt | |
| 293 | \inst@allfonts | |
| 294 | } | |
| 295 | ||
| 296 | \def\inst@allfonts{ | |
| 297 | \skewchar\teni='177 \skewchar\seveni='177 \skewchar\fivei='177 | |
| 298 | \skewchar\tensy='60 \skewchar\sevensy='60 \skewchar\fivesy='60 | |
| 299 | ||
| 300 | \textfont0=\tenr \scriptfont0=\sevenr \scriptscriptfont0=\fiver | |
| 301 | \textfont1=\teni \scriptfont1=\seveni \scriptscriptfont1=\fivei | |
| 302 | \textfont2=\tensy \scriptfont2=\sevensy \scriptscriptfont2=\fivesy | |
| 303 | \textfont3=\tenex \scriptfont3=\tenex \scriptscriptfont3=\tenex | |
| 304 | \textfont\itfam=\tenit \scriptfont\itfam=\sevenit \scriptscriptfont\itfam=\fiveit | |
| 305 | \textfont\slfam=\tensl | |
| 306 | \textfont\bffam=\tenbf \scriptfont\bffam=\sevenbf | |
| 307 | \scriptscriptfont\bffam=\fivebf | |
| 308 | \textfont\ttfam=\tentt | |
| 309 | \tenrm | |
| 310 | } | |
| 311 | \def\rm{\fam0\tenrm} | |
| 312 | \def\mit{\fam1} \def\oldstyle{\fam\@ne\teni} | |
| 313 | \def\cal{\fam2} | |
| 314 | % fam 3 contains the large symbols, cannot be used for ordinary math | |
| 315 | \newfam\itfam \def\it{\fam\itfam\tenit} % \it is family 4 | |
| 316 | \newfam\slfam \def\sl{\fam\slfam\tensl} % \sl is family 5 | |
| 317 | \newfam\bffam \def\bf{\fam\bffam\tenbf} % \bf is family 6 | |
| 318 | \newfam\ttfam \def\tt{\fam\ttfam\tentt} % \tt is family 7 | |
| 319 | ||
| 320 | % If you don't have `msb' fonts, replace the next 4 lines by `\let\Bbb=\bf'. | |
| 321 | \newfam\msbfam \def\Bbb{\fam\msbfam} | |
| 322 | \font\tenmsb=msbm10 \textfont\msbfam=\tenmsb | |
| 323 | \font\sevenmsb=msbm7 \scriptfont\msbfam=\sevenmsb | |
| 324 | \font\fivemsb=msbm5 \scriptscriptfont\msbfam=\fivemsb | |
| 325 | \font\sevenmsa=msam7 | |
| 326 | ||
| 327 | % the dark triangle | |
| 328 | \def\darktriangleright{\raise.4ex\hbox{\sevenmsa\char"49}} | |
| 329 | ||
| 330 | % Math mode should use text italic. | |
| 331 | {\count0=\itfam \advance\count0 by-1 \multiply\count0 by"100 | |
| 332 | \count1=`A | |
| 333 | \loop \count2=\mathcode\count1 \advance\count2 by\count0 | |
| 334 | \global\mathcode\count1=\count2 | |
| 335 | {\advance\count1 by'040 | |
| 336 | \count2=\mathcode\count1 \advance\count2 by\count0 | |
| 337 | \global\mathcode\count1=\count2} | |
| 338 | \ifnum\count1<`Z \advance\count1 by1\repeat} | |
| 339 | ||
| 340 | \usepsfonts | |
| 341 | ||
| 342 | % macros for verbatim scanning (almost copied from `The TeXbook') | |
| 343 | \chardef\other=12 | |
| 344 | \def\undocatcodespecials{\catcode`\\=\other \catcode`\{=\other | |
| 345 | \catcode`\}=\other \catcode`\<=\other \catcode`\$=\other | |
| 346 | \catcode`\%=\other \catcode`\~=\other \catcode`\^=\other | |
| 347 | \catcode`\_=\other \catcode`\*=\other \catcode`\`=\other | |
| 348 | \catcode`\!=\other \catcode`\"=\other \catcode`\&=\other | |
| 349 | \catcode`\#=\other \catcode`\|=\other} | |
| 350 | \newdimen\ttindent \ttindent=5mm % indentation amount of verbatim examples | |
| 351 | \def\kernttindent{\hskip\ttindent\relax} % for use in %\begintt | |
| 352 | {\obeyspaces\global\let =\ } | |
| 353 | {\obeylines\gdef\obeylines{\catcode`^^M=\active}\gdef^^M{\par}% | |
| 354 | \catcode`#=\active \catcode`&=6 \gdef#{\char35}% | |
| 355 | %\catcode`#=\active \catcode`&=6 \gdef#&1^^M{\hbox{\char35 &1}^^M}% | |
| 356 | \gdef\ttverbatim{\begingroup\undocatcodespecials \catcode`\#=\active% | |
| 357 | \parindent 0pt \def\_^^M{\allowbreak}\def\${$}\def\`{`}% | |
| 358 | \def\par{\ifvmode\allowbreak\vskip 1pc plus 1pt\else\endgraf\penalty100\relax\fi}% | |
| 359 | \obeyspaces \obeylines \tt}} | |
| 360 | \outer\def\begintt{\par | |
| 361 | \begingroup\advance\leftskip by \ttindent | |
| 362 | \ttverbatim \parskip=0pt \catcode`\|=0 \rightskip-5pc \ttfinish} | |
| 363 | {\catcode`\|=0 |catcode`|\=\other % | is temporary escape character | |
| 364 | |obeylines % end of line is active | |
| 365 | |gdef||{|char124} % | |
| 366 | |gdef|ttfinish^^M#1\endtt{|medskip{#1}|endgroup % | |
| 367 | |endgroup% | |
| 368 | |vskip-|parskip|medskip|noindent|ignorespaces}} | |
| 369 | \def\unstableoutput{} | |
| 370 | \outer\def\beginexample{\par | |
| 371 | \begingroup\advance\leftskip by \ttindent | |
| 372 | \ttverbatim \parskip=0pt \catcode`\|=0 \rightskip-5pc \catcode`\#=\other\examplefinish} | |
| 373 | {\catcode`\|=0 |catcode`|\=\other % | is temporary escape character | |
| 374 | |obeylines % end of line is active | |
| 375 | |gdef||{|char124} % | |
| 376 | |gdef|examplefinish^^M#1^^M\endexample{% | |
| 377 | |iftestexample% | |
| 378 | |ifexamplefileopen% | |
| 379 | |else|immediate|openout|exampleout=|jobname.example-|the|chapno.tst% | |
| 380 | |global|examplefileopentrue% | |
| 381 | |fi% | |
| 382 | {|def^^M{^^J}|immediate|write|exampleout{#1}}% | |
| 383 | |fi% | |
| 384 | |global|testexampletrue% | |
| 385 | |medskip{#1}|endgroup% | |
| 386 | |vskip-|parskip|medskip|endgroup% | |
| 387 | |noindent|ignorespaces}} | |
| 388 | ||
| 389 | % Input/output streams. Chapter and section counters. | |
| 390 | \newwrite\labelout \newwrite\indexout \newwrite\secindout | |
| 391 | \newwrite\tocout \newwrite\citeout \newwrite\ans | |
| 392 | \newwrite\exampleout | |
| 393 | \newif\ifexamplefileopen | |
| 394 | \newif\iftestexample\global\testexampletrue | |
| 395 | \newread \labelin \newread \indexin \newread \tocin \newread \citein | |
| 396 | \countdef\chapno=1 \newcount\secno \newcount\subsecno \newcount\exno | |
| 397 | \newcount\indentno | |
| 398 | \newcount\chapnum %GG \chapnum is a numerical \chapno for the .six file | |
| 399 | \def\chapterno{{\edef\tempa{\thechapter}\tempa}} | |
| 400 | %\def\folio{\ifnum\pageno<0 \romannumeral-\pageno \else | |
| 401 | % \chapterno\ifx\thechapter\emptychapter\else--\fi \number\pageno\fi} | |
| 402 | %\def\doindex#1#2#3{\write\indexout{\noexpand\indexentry{#1#2#3}% | |
| 403 | % {\ifnum\pageno<0 \romannumeral-\pageno \else | |
| 404 | % \thechapter\ifx\thechapter\emptychapter\else--\fi \number\pageno\fi}}% | |
| 405 | % \ifvmode\nobreak\fi} | |
| 406 | ||
| 407 | %AH | |
| 408 | \def\folio{\ifnum\pageno<0 \romannumeral-\pageno \else | |
| 409 | \number\pageno\fi} | |
| 410 | ||
| 411 | %\def\doindex#1#2#3{\protectedwrite\indexout{\noexpand\indexentry{#1#2#3}% | |
| 412 | % {\ifnum\pageno<0\romannumeral-\pageno\else% | |
| 413 | % \number\pageno\fi}}% | |
| 414 | % \ifvmode\nobreak\else\unskip\fi} | |
| 415 | ||
| 416 | {\catcode`<=\active \catcode`_=\active \catcode`!=\active \catcode`*=\active | |
| 417 | \catcode``=\active | |
| 418 | ||
| 419 | \global\let\n@exp\noexpand | |
| 420 | ||
| 421 | \gdef\doindex#1#2#3{\begingroup | |
| 422 | %\let_\underscore\let`\lq\let<\<\let!\excl | |
| 423 | \def\noexpand{}% this kills noexpands from some index entries | |
| 424 | \def\protect{\n@exp\n@exp\n@exp}% | |
| 425 | \def_{\protect_}\def*{\protect*}\def`{\protect `}\def<{\protect <}\def!{\protect!}% | |
| 426 | \edef\tmp{\n@exp\n@exp\n@exp\indexentry{#1#2#3}}% | |
| 427 | \expandafter\write\expandafter\indexout\expandafter{\tmp{\folio}}% | |
| 428 | %{\scrollmode\errorcontextlines 1\show\tmp\errorstopmode}% | |
| 429 | \ifvmode\nobreak\else\unskip\fi\endgroup}% | |
| 430 | } | |
| 431 | ||
| 432 | % Additional active characters and their default meanings. | |
| 433 | \mathcode`.="2201 \mathchardef\.="702E | |
| 434 | \def\undoquotes{\catcode`'=12 \catcode``=12 \def\"##1{{\accent127 ##1}}} | |
| 435 | \def\excl{!} \chardef\lqq=`\\ \let\underscore=\_ | |
| 436 | \chardef\<=`< | |
| 437 | \catcode`!=\active \let!=\excl | |
| 438 | \catcode`^=\active \def^{\ifmmode\sp\else{\char`\^}\fi} | |
| 439 | \catcode`_=\active \def\activeusc{\ifmmode\sb\else\_\fi} | |
| 440 | \let_=\activeusc \let\_=\underscore | |
| 441 | \catcode`*=\active \def*{\ifmmode\let\next=\*\else\let\next=\bold\fi\next} | |
| 442 | \def\bold#1*{{\bf #1\/}} \chardef\*=`* | |
| 443 | \catcode`<=\active \def<#1>{{\chardef*=`*\let_=\_\it#1\/}} | |
| 444 | ||
| 445 | \catcode`"=\active \def"{\begingroup\undoquotes\doref} \chardef\"=`" | |
| 446 | \chardef\\=`\\ | |
| 447 | ||
| 448 | \def\refManual{{\GAP} Reference Manual} | |
| 449 | \def\tutManual{{\GAP} Tutorial} | |
| 450 | ||
| 451 | {\catcode`|=0 \catcode`\\=12 |gdef|bs{\}} | |
| 452 | % Labels (which are automatically generated by ``\Section'' and ``\>''). | |
| 453 | %\newif\iflabmultdef | |
| 454 | \newif\iflabundef | |
| 455 | \newif\iflabchanged | |
| 456 | \newif\ifcasesensitive | |
| 457 | \newif\ifcitebooks | |
| 458 | ||
| 459 | \def\doref#1"{\bookref#1:"} | |
| 460 | \def\bookref#1:#2"{\def\tempa{#2}\ifx\tempa\empty\printref{\book:#1}\else | |
| 461 | \printbookref#1:#2"\fi} | |
| 462 | \def\printbookref#1:#2:"{\printref{#1:#2}} | |
| 463 | ||
| 464 | % Macros which write labels, citations and index entries on auxiliary files. | |
| 465 | % | |
| 466 | % 1. Some code was moved around so that all the labels and indexing stuff | |
| 467 | % would be together. | |
| 468 | % 2. Modified \makelabel, \printref and \label to be more like the LaTeX | |
| 469 | % commands \newlabel, \ref and \label, respectively. The commands: | |
| 470 | % \@xp, \@firstoftwo, \@secondoftwo, \namedef, \@ifundefined | |
| 471 | % \protectedwrite are adapted pieces of LaTeX code (\@xp is actually | |
| 472 | % AmSLaTeX's abbreviation of \expandafter). | |
| 473 | % 3. The upshot of 2. is that now underscore is allowed in labels and | |
| 474 | % index-entries and that the \makelabel commands written to the | |
| 475 | % manual.lab files have arguments that are no longer put in lowercase. | |
| 476 | % The labels formed inside TeX from the \makelabel commands maps | |
| 477 | % underscores to | (needed to be a non-active character) and then | |
| 478 | % converts to lowercase. | |
| 479 | % 4. Since GapDoc uses < and > in some of its labels a temporary re-defintion | |
| 480 | % of <#1> was necessary, inside \@xplowr. | |
| 481 | % - GG 2001/06/11, 2001/09/02 | |
| 482 | ||
| 483 | \let\@xp\expandafter | |
| 484 | \long\def\@firstoftwo#1#2{#1} | |
| 485 | \long\def\@secondoftwo#1#2{#2} | |
| 486 | \def\namedef#1{\expandafter\def\csname #1\endcsname} | |
| 487 | \def\@ifundefined#1{\@xplowr{#1}% | |
| 488 | \@xp\ifx\csname \xpandlowr\endcsname\relax% | |
| 489 | \@xp\@firstoftwo% | |
| 490 | \else% | |
| 491 | \@xp\@secondoftwo% | |
| 492 | \fi} | |
| 493 | \def\protectedwrite#1#2{\begingroup\let_\relax\immediate\write#1{#2}\endgroup} | |
| 494 | \def\@xplowr#1{\begingroup\def_{|}\def<##1>{|##1|}\let\next=\relax% | |
| 495 | \expandafter\edef\next{\gdef\noexpand\xpandlowr{#1}}% | |
| 496 | \ifcasesensitive\next\else\lowercase\expandafter{\next}\fi\endgroup} | |
| 497 | \def\m@kelabel#1#2#3{\@xplowr{r@#1}% | |
| 498 | \@ifundefined{\xpandlowr}% | |
| 499 | \relax% | |
| 500 | {\let_\activeusc}%\protectedwrite{16}{Label `#1' multiply defined.}}% | |
| 501 | \let_\activeusc%\protectedwrite{16}{Defined label `#1'.}% | |
| 502 | \begingroup\edef_{|}\global\namedef{\xpandlowr}{#2}\endgroup} | |
| 503 | \let\makelabel\undefined | |
| 504 | \gdef\printref#1{\@xplowr{#1}% | |
| 505 | \@xp\ifx\csname r@\xpandlowr\endcsname\relax\lqq\xpandlowr''% | |
| 506 | \protectedwrite{16}{Label `#1' undefined.}\global\labundeftrue% | |
| 507 | \else\expandafter\printpdflink\xpandlowr\relax\fi\endgroup\let_\activeusc} | |
| 508 | \gdef\printpdflink#1:#2\relax{\edef\next{#1}\ifx\next\book | |
| 509 | \startlink{#2}\csname r@\xpandlowr\endcsname\endlink\else | |
| 510 | \ifcitebooks\expandafter\csname\next Manual\endcsname,\space\fi | |
| 511 | \csname r@\xpandlowr\endcsname\fi} | |
| 512 | ||
| 513 | \newif\ifnewlab | |
| 514 | ||
| 515 | % Macros which write labels, citations and index entries on auxiliary files. | |
| 516 | \gdef\label#1{\@xplowr{#1}% | |
| 517 | \ifnum\secno=0 \edef\@currentlabel{\thechapter}\else | |
| 518 | \ifnum\subsecno=0 \edef\@currentlabel{\thechapter.\the\secno}\else | |
| 519 | \edef\@currentlabel{\thechapter.\the\secno.\the\subsecno}\fi\fi | |
| 520 | \@xp\ifx\csname r@\book:\xpandlowr\endcsname\@currentlabel\else% | |
| 521 | %\immediate\write16{Label `\book:#1' has changed.}% | |
| 522 | \global\labchangedtrue\fi% | |
| 523 | \expandafter\ifx\csname pdfdest@\xpandlowr\endcsname\relax | |
| 524 | \nameddest{\xpandlowr}% | |
| 525 | \expandafter\gdef\csname pdfdest@\xpandlowr\endcsname{#1}% | |
| 526 | \fi% | |
| 527 | \ifnewlab\def\next{{\xpandlowr}}% | |
| 528 | \else | |
| 529 | \def\next{}% | |
| 530 | \fi | |
| 531 | \protectedwrite\labelout{\string\makelabel{\book:#1}{\@currentlabel}\next}% | |
| 532 | \let_\activeusc} | |
| 533 | ||
| 534 | \def\litem#1{% left aligned item | |
| 535 | \par\hang\noindent\hbox to \parindent{#1\enspace\hfill}} | |
| 536 | ||
| 537 | \newif\ifbiblitem | |
| 538 | ||
| 539 | \gdef\sigel#1{[\expandafter\ifx\csname c@#1\endcsname\relax | |
| 540 | \immediate\write16{Reference `#1' undefined.}\global\labundeftrue | |
| 541 | #1\else \csname c@#1\endcsname\fi]} | |
| 542 | \gdef\bibitem[#1]#2{\expandafter\gdef\csname c@#2\endcsname{#1}% | |
| 543 | \nameddest{citation@#2}\ifbiblitem\litem{\sigel{#2}}\else\item{\sigel{#2}}\fi | |
| 544 | \immediate\write\labelout{\noexpand\setcitlab{#2}\noexpand{#1}}\ignorespaces} | |
| 545 | \gdef\setcitlab#1#2{\expandafter\gdef\csname c@#1\endcsname{#2}} | |
| 546 | ||
| 547 | \def\cite#1{\write\citeout{\bs citation{#1}}\startlink{citation@#1}\sigel{#1}\endlink} | |
| 548 | \def\dosecindex#1#2#3{\ifchapter{\let\ =\space% | |
| 549 | \protectedwrite\secindout{#1 \the\chapno.\the\secno. #2#3}}\fi} | |
| 550 | \def\bothindex#1#2#3#4{\doindex{#2}{#3}{#4}\dosecindex{#1}{#2}{#4}} | |
| 551 | \def\index#1{\bothindex I{#1}{}{}} | |
| 552 | \def\atindex#1#2{\doindex{\scrubafterexcl#1!\end}{#2}{}\dosecindex I{#1}{}} | |
| 553 | {\catcode64=12 | |
| 554 | \gdef\indextt#1{\doindex{\scrubafterexcl#1!\end}% | |
| 555 | {@`\scrubafterexcl#1!\end'\scrubbeforeexcl#1!\end}{}\dosecindex I{#1}{}} | |
| 556 | } | |
| 557 | %\def\indextt#1{\atindex{#1}{@`#1'}} | |
| 558 | \def\indexit#1{{\it #1}} | |
| 559 | ||
| 560 | % Macros for generating the table of contents. | |
| 561 | \newif\iffirstsec \firstsectrue | |
| 562 | \def\dotsfill{\leaders\hbox to12pt{\hss.\hss}\hfill} | |
| 563 | ||
| 564 | \def\appcontents#1#2#3{} | |
| 565 | ||
| 566 | \def\chapcontents#1#2#3{% | |
| 567 | %\iffirstsec\firstsecfalse\else\line{}\fi% empty line | |
| 568 | \par\penalty-5\medskip | |
| 569 | \line{\@xplowr{#2}\startlink{\xpandlowr}\bf\kern\manindent\vbox{\advance\hsize by-\manindent | |
| 570 | \advance\hsize by-1.5em | |
| 571 | \rightskip 0pt plus1fil \emergencystretch 3em | |
| 572 | \noindent\llap{\hbox to\manindent{\hss #1\kern\smallmanindent}}\strut | |
| 573 | #2~\hfill \strut\rlap{\hbox to1.5em{\hss #3}}}\hfil\endlink}} | |
| 574 | ||
| 575 | \def\seccontents#1#2#3{ | |
| 576 | \par\penalty-5\medskip | |
| 577 | \setchapterlen#1. | |
| 578 | \line{\@xplowr{#2}\startlink{\xpandlowr}\kern\manindent\vbox{\advance\hsize by-\manindent | |
| 579 | \advance\hsize by-1.5em | |
| 580 | \rightskip 0pt plus1fil \emergencystretch 3em | |
| 581 | \noindent\llap{\hbox to\manindent{\hss #1\kern\smallmanindent}}\strut | |
| 582 | #2~\dotsfill \strut\rlap{\hbox to1.5em{\hss #3}}}\hfil\endlink}} | |
| 583 | ||
| 584 | % GG ... the idea of \ors is to put the right no. of \or s in the \appno | |
| 585 | % macro so that for an appendix: | |
| 586 | % 1. \the\chapno gives the number needed in the .six file, and | |
| 587 | % 2. \appno\chapno gives the right letter A, B, ... for the .lab file | |
| 588 | \newtoks\ortoks | |
| 589 | \long\def\addor{\begingroup\ortoks\expandafter{\ors\or} | |
| 590 | \xdef\ors{\the\ortoks}\endgroup} | |
| 591 | \def\setors{{\xdef\ors{} \count0=\chapno | |
| 592 | \loop\ifnum\count0>0 \addor \advance\count0 by -1\repeat}} | |
| 593 | \def\appno#1{\expandafter\ifcase\expandafter#1\ors\or A\or B\or C\or D\or E\or | |
| 594 | F\or G\or H\or I\or J\or K\or L\or M\or N\or O\or P\or Q\or R\or S\or T\or | |
| 595 | U\or V\or W\or X\or Y\or Z\else\immediate\write16{Counter too large} \fi} | |
| 596 | ||
| 597 | % Macros for chapter and section headings. | |
| 598 | \def\filename{appendix} | |
| 599 | \def\tocstrut{{\setbox0=\hbox{1}\vrule width 0pt height\ht0}} | |
| 600 | \outer\def\Input#1{\def\filename{#1.tex}\input #1} | |
| 601 | \def\emptychapter{\noexpand\tocstrut} | |
| 602 | \def\normalchapter{\the\chapno} | |
| 603 | % GG | |
| 604 | \def\appendixchapter{\appno\chapno} % \appno behaves like LaTeX's \Alph | |
| 605 | \newif\ifchapter % set to true when \thechapter = \normalchapter | |
| 606 | % ... or ... when \thechapter = \appendixchapter | |
| 607 | ||
| 608 | { | |
| 609 | % | |
| 610 | \gdef\setchapterlen#1.#2.{\expandafter\gdef\csname ch@#1\endcsname{#2}} | |
| 611 | \gdef\chapterlen#1{% | |
| 612 | \ifchapter | |
| 613 | \expandafter\ifx\csname ch@#1\endcsname\relax% | |
| 614 | 0% | |
| 615 | \else\csname ch@#1\endcsname\fi | |
| 616 | \else 0\fi}% | |
| 617 | } | |
| 618 | \def\setindent#1{\indentno=#1} | |
| 619 | ||
| 620 | \outer\def\Chapter#1 \par{\doChapter{#1}{}} | |
| 621 | ||
| 622 | \def\doChapter#1#2{\vfill\supereject \headlinefalse | |
| 623 | % \ifodd\pageno\else\null\vfill\eject\headlinefalse\fi | |
| 624 | \ifexamplefileopen\immediate\closeout\exampleout\examplefileopenfalse\fi | |
| 625 | \advance\chapno by1 \secno=0\subsecno=0\exno=0%\ifnum\pageno>0 \pageno=1 \fi | |
| 626 | \def\chapname{#1#2}\label{#1}\ifx\relax#2\relax\else\label{#1#2}\fi% | |
| 627 | \immediate\write16{Chapter `#1' .}% | |
| 628 | \write\tocout{\noexpand\chapcontents{\thechapter}{#1#2}{\the\pageno}}% | |
| 629 | \ifchapter | |
| 630 | \immediate\write\secindout{C \filename\space\the\chapno. \chapname}\fi | |
| 631 | \@xplowr{#1}\setbookmarkind{\xpandlowr}{#1#2}% | |
| 632 | \setbox0=\hbox{\inchhigh\kern-.075em \chapterno}% | |
| 633 | \setbox1=\vbox{\titlefont \advance\hsize by-\wd0 \advance\hsize by-1em | |
| 634 | % \hyphenpenalty=10000 \linepenalty=10000 | |
| 635 | \leftskip 0pt plus\hsize \parfillskip 0pt \baselineskip 44pt\relax #1#2}% | |
| 636 | \line{\box0\hfil\box1}\nobreak \mark{}\vskip 40pt} | |
| 637 | ||
| 638 | % start hack added by TB | |
| 639 | \outer\def\PreliminaryChapter#1 \par{\doChapter{#1}{ (preliminary)}} | |
| 640 | ||
| 641 | \outer\def\Section#1#2\par{\bigbreak \advance\secno by1 | |
| 642 | \subsecno=0 | |
| 643 | \ifx\thechapter\emptychapter | |
| 644 | \edef\tempa{\the\secno} | |
| 645 | \else | |
| 646 | \edef\tempa{\thechapter.\the\secno}% | |
| 647 | \fi% | |
| 648 | \@xplowr{#1}\setbookmark{\xpandlowr}{#1} | |
| 649 | \expandafter\writesecline\tempa\\{#1} | |
| 650 | \dosecindex S{#1}{} | |
| 651 | \ifx#2\nolabel\nameddest{\xpandlowr}\else{\let\ =\space\label{#1}}\fi | |
| 652 | \ifx#2\null\else \edef\tempb{{#1@#1}} | |
| 653 | \expandafter\doindex\tempb{|indexit}{}\fi | |
| 654 | \noindent{\baselineskip 18pt\let!=\space \mark{Section \the\secno. #1}% | |
| 655 | \secfont \tempa \enspace #1}\par\nobreak\medskip} | |
| 656 | ||
| 657 | \def\writesecline#1\\#2{\write\tocout{\noexpand\seccontents{#1}{#2} | |
| 658 | {\the\pageno}}} | |
| 659 | \def\letter#1{% | |
| 660 | \edef\tempa{LeTtEr#1}% | |
| 661 | \nameddest{\tempa}% | |
| 662 | \setbookmark{\tempa}{#1}% | |
| 663 | \medskip{\secfont #1}\endgraf\nobreak} | |
| 664 | ||
| 665 | % Macros for generating paragraph headings (e.g., function descriptions). | |
| 666 | \def\fmark{\noindent\llap{\darktriangleright\rm\enspace}} | |
| 667 | \def\moveup#1{\leavevmode \raise.16ex\hbox{\rm #1}} | |
| 668 | \def\fpar{\endgraf\endgroup\nobreak\smallskip\noindent\ignorespaces} | |
| 669 | \def\>{\begingroup\undoquotes\obeylines\angle} | |
| 670 | \def\){\begingroup\obeylines\cloparen} | |
| 671 | {\obeylines\catcode64=12 | |
| 672 | \gdef\angle#1 | |
| 673 | {\endgroup \ifx\par\fpar \global\def\susemarker{\fmark}\else% | |
| 674 | \global\advance\subsecno by1% | |
| 675 | \global\def\susemarker{\noindent\llap{\smallrom\the\subsecno\kern.5ex% | |
| 676 | \darktriangleright\rm\enspace}}% | |
| 677 | \ifvmode \vskip -\lastskip \fi \medskip% | |
| 678 | \begingroup\let\par=\fpar \parskip 0pt \fi% | |
| 679 | \endgraf\nobreak\oporfunc#1\end}% | |
| 680 | \gdef\cloparen#1 | |
| 681 | {\endgroup \ifx\par\fpar \else% | |
| 682 | \ifvmode \vskip -\lastskip \fi \medskip% | |
| 683 | \begingroup\let\par=\fpar \parskip 0pt \fi% | |
| 684 | \endgraf{\def\[{\moveup\lbrack}\def\]{\moveup\rbrack}\def\|{\vrule\relax}% | |
| 685 | \noindent\typewriter#1'}}% | |
| 686 | \gdef\scanparen#1(#2\end{\def\tempa{#2}\ifx\tempa\empty% | |
| 687 | \def\next{\begingroup\cloparen\susemarker#1% | |
| 688 | \label{#1}\bothindex F{#1}{@`#1'}{}}% | |
| 689 | \else\def\next{\delparen#1(#2\end}\fi \next}% | |
| 690 | \gdef\delparen#1(\end{\function#1}% | |
| 691 | \gdef\oporfunc#1#2\end{\ifx#1`\def\next{\oporvalue#1#2}\else% | |
| 692 | \def\next{\scanparen#1#2(\end}\fi \next}% | |
| 693 | \long\gdef\oporvalue`#1'#2{\ifx#2V\def\next{\operation`#1'{#1}@{`#1'} V}\else% | |
| 694 | \def\next{\operation`#1'{#2}}\fi \next}% | |
| 695 | \long\gdef\operation`#1'#2#3{{\def\[{\moveup\lbrack}\def\]{\moveup\rbrack}% | |
| 696 | \def\|{\vrule\relax}}% | |
| 697 | \susemarker\typewriter#1'% | |
| 698 | \ifx#3!\def\next{\suboperation{#2}}% | |
| 699 | \else\ifx#3@\def\next{\subatoperation{#2}}% | |
| 700 | \else\endheaderline \label{#2}% | |
| 701 | \bothindex F{#2}{}{}\let\next=#3\fi\fi\next}% | |
| 702 | \long\gdef\function#1(#2)#3{{\def\[{\moveup\lbrack}\def\]{\moveup\rbrack}% | |
| 703 | \def\|{\vrule\relax}% | |
| 704 | \susemarker\typewriter#1(#2)'}% | |
| 705 | \ifx#3!\def\next{\subfunction{#1}}\else% | |
| 706 | \endheaderline\label{#1}\bothindex F{#1}{@`#1'}{}% | |
| 707 | \let\next=#3\fi\next}% | |
| 708 | \gdef\subfunction#1#2{\endheaderline\label{#1!#2}% | |
| 709 | \bothindex F{#1}{@`#1'}{!#2}}% | |
| 710 | \gdef\suboperation#1#2{\endheaderline\label{#1!#2}% | |
| 711 | \bothindex F{#1}{}{!#2}}% | |
| 712 | \gdef\subatoperation#1#2{\endheaderline\label{#1}% | |
| 713 | \doindex{\scrubafterexcl#1!\end}{@#2}{}% | |
| 714 | \dosecindex F{#1}{}}% | |
| 715 | \gdef\scrubafterexcl#1!#2\end{#1}% | |
| 716 | \gdef\scrubbeforeexcl#1!#2\end{\if\relax#2\else!\removeendexcl#2\fi}% | |
| 717 | \gdef\removeendexcl#1!{#1}% | |
| 718 | \gdef\endheaderline{\hskip 0pt plus 1filll}% | |
| 719 | } | |
| 720 | ||
| 721 | % Macro for item lists. | |
| 722 | \catcode`&=\active | |
| 723 | \def\beginitems{% | |
| 724 | \smallskip | |
| 725 | \begingroup | |
| 726 | \advance\ttindent\manindent | |
| 727 | \def&{\par \nobreak \hangindent\manindent \hangafter 0 | |
| 728 | {\parskip 0pt\noindent}\ignorespaces} | |
| 729 | \parindent 0pt | |
| 730 | \catcode`&=\active | |
| 731 | } | |
| 732 | \def\enditems{\par \endgroup \smallskip \noindent \ignorespaces} | |
| 733 | ||
| 734 | % Macro for item lists. | |
| 735 | \def\beginlist{% | |
| 736 | \smallskip | |
| 737 | \begingroup | |
| 738 | \parindent=2em | |
| 739 | } | |
| 740 | \def\endlist{\par \endgroup \smallskip \noindent \ignorespaces} | |
| 741 | \catcode`&=4 | |
| 742 | ||
| 743 | % Macros for exercises. | |
| 744 | \outer\def\exercise{\advance\exno by1\begingroup | |
| 745 | \def\par{\endgraf\endgroup\medskip\noindent} | |
| 746 | \medskip\noindent{\bf Exercise \chapterno.\the\exno.}\quad} | |
| 747 | \outer\def\answer{\immediate\write\ans{}% | |
| 748 | \immediate\write\ans{\noexpand\answerto{\thechapter.\the\exno.}}% | |
| 749 | \copytoblankline} | |
| 750 | \def\answerto#1{{\noindent\bf #1}} | |
| 751 | \def\copytoblankline{\begingroup\setupcopy\copyans} | |
| 752 | {\undoquotes | |
| 753 | \gdef\setupcopy{\undocatcodespecials \obeylines \obeyspaces} | |
| 754 | \obeylines \gdef\copyans#1 | |
| 755 | {\def\next{#1}% | |
| 756 | \ifx\next\empty\let\next=\endgroup % | |
| 757 | \else\immediate\write\ans{\next}\let\next=\copyans\fi\next}} | |
| 758 | ||
| 759 | % Macros for the active backquote character (`). | |
| 760 | {\catcode`.=\active \gdef.{\char'056 \penalty0}} | |
| 761 | \def\writetyper{\catcode`.=\active \chardef\{ =`{ \chardef\}=`} | |
| 762 | \chardef*=`* \chardef"=`" \chardef~=`~} | |
| 763 | \catcode``=\active | |
| 764 | \def`{\futurelet\next\backquote} | |
| 765 | \def\typewriter#1'{\leavevmode{\writetyper \chardef`=96 \tt #1}} | |
| 766 | \def\backquote{\ifx\next`\let\next=\doublebackquote | |
| 767 | \else\let\next=\typewriter \fi \next} | |
| 768 | \def\doublebackquote`{\lqq} | |
| 769 | ||
| 770 | % The \Package command for argument <pkg> defines a macro \<pkg> that | |
| 771 | % sets the text <pkg> in sans-serif i.e. a share package author should | |
| 772 | % put a \Package{<pkg>} in their manual.tex file and then use {\<pkg>} | |
| 773 | % when they refer to package <pkg>. | |
| 774 | ||
| 775 | \def\Package#1{\namedef{#1}{{\sf #1}}} | |
| 776 | \Package{GAP} | |
| 777 | \Package{MOC} | |
| 778 | \Package{ATLAS} | |
| 779 | ||
| 780 | % For one-off references to a share package there is the following: | |
| 781 | ||
| 782 | \def\package#1{{\sf #1}} | |
| 783 | ||
| 784 | % The day | |
| 785 | ||
| 786 | \def\Day{\number\day} | |
| 787 | ||
| 788 | % The month in words | |
| 789 | ||
| 790 | \def\Month{\ifcase\month\or January\or February\or March\or April\or May\or | |
| 791 | June\or July\or August\or September\or October\or November\or December\fi} | |
| 792 | ||
| 793 | % The year | |
| 794 | ||
| 795 | \def\Year{\number\year} | |
| 796 | ||
| 797 | % The date | |
| 798 | ||
| 799 | \def\Today{{\Day} {\Month} {\Year}} | |
| 800 | ||
| 801 | % Miscellaneous macros. | |
| 802 | \def\N{{\Bbb N}} \def\Z{{\Bbb Z}} \def\Q{{\Bbb Q}} \def\R{{\Bbb R}} | |
| 803 | \def\C{{\Bbb C}} \def\F{{\Bbb F}} \def\calR{{\cal R}} | |
| 804 | ||
| 805 | %T do we want these | |
| 806 | %\def\stars{\bigskip\centerline{\*\qquad\*\qquad\*}\bigskip} | |
| 807 | ||
| 808 | % Page numbers and running heads. | |
| 809 | \newif\ifheadline | |
| 810 | \nopagenumbers | |
| 811 | \def\makeheadline{\vbox to0pt{\vskip-22.5pt\hbox to\pagewidth{\vbox to8.5pt | |
| 812 | {}\the\headline}\vss}\nointerlineskip} | |
| 813 | \headline={\ifheadline\ifodd\pageno \righthead\hfil{\rm\folio}\else | |
| 814 | {\rm\folio}\hfil\lefthead \fi | |
| 815 | \else\global\headlinetrue \hfil\fi} | |
| 816 | ||
| 817 | % Macro for inputting an auxiliary file. | |
| 818 | \def\inputaux#1#2{\immediate\openin#1=#2 | |
| 819 | \ifeof#1\immediate\write16{No file #2.}\else | |
| 820 | \immediate\closein#1 \input#2\fi} | |
| 821 | ||
| 822 | % Macros for the parts of the manual. | |
| 823 | \outer\def\FrontMatter{% | |
| 824 | \let\thechapter=\emptychapter | |
| 825 | \def\lefthead{\it\chapname} \let\righthead=\lefthead | |
| 826 | ||
| 827 | \begingroup | |
| 828 | \def\makelabel##1##2{\m@kelabel{##1}{##2}{}}% | |
| 829 | \undoquotes | |
| 830 | \inputaux\labelin{\jobname.lab} | |
| 831 | %\setbox0=\vbox{\Bibliography} | |
| 832 | \endgroup | |
| 833 | \labchangedfalse | |
| 834 | ||
| 835 | % Open the auxiliary files for output. | |
| 836 | \immediate\openout\tocout =\jobname.toc | |
| 837 | \immediate\openout\labelout =\jobname.lab | |
| 838 | \immediate\openout\indexout =\jobname.idx | |
| 839 | \immediate\openout\secindout=\jobname.six | |
| 840 | \immediate\openout\citeout =\jobname.aux | |
| 841 | % \immediate\openout\ans=answers | |
| 842 | \immediate\write\citeout{\bs bibstyle{alpha}} | |
| 843 | ||
| 844 | \ifodd\pageno\else\headlinefalse\null\vfill\eject\fi | |
| 845 | % \pageno=1 | |
| 846 | } | |
| 847 | ||
| 848 | \outer\def\Chapters{\vfill\eject | |
| 849 | \chapno=0 \let\thechapter=\normalchapter \chaptertrue | |
| 850 | \def\lefthead{{\it Chapter \the\chapno. \chapname}} | |
| 851 | \def\righthead{\ifx\botmark\empty\lefthead\else{\it \botmark}\fi}} | |
| 852 | ||
| 853 | % GG | |
| 854 | % Rather than reset \chapno in \Appendices, for the .six file (which GAP's | |
| 855 | % help uses), we number appendices as if they were chapters (via \the\chapno) | |
| 856 | % i.e. if the last chapter was numbered 7 then for the .six file the first | |
| 857 | % appendix would be numbered 8. | |
| 858 | % The \setors macro puts (\number\chapno - 1) \or s in the \ors macro so that | |
| 859 | % \appno\chapno (= \appendixchapter) numbers the appendices sequentially from A | |
| 860 | % for the .lab file (which TeX uses). | |
| 861 | \outer\def\Appendices{\vfill\eject | |
| 862 | \ifexamplefileopen\immediate\closeout\exampleout\examplefileopenfalse\fi | |
| 863 | \setors \let\thechapter=\appendixchapter \chaptertrue | |
| 864 | \def\lefthead{{\it Appendix \thechapter. \chapname}} | |
| 865 | \def\righthead{\ifx\botmark\empty\lefthead\else{\it \botmark}\fi}} | |
| 866 | ||
| 867 | \def\EndMatter{\vfill\eject | |
| 868 | \def\thechapter{} \chapterfalse | |
| 869 | \def\lefthead{{\it \chapname}} | |
| 870 | \let\righthead=\lefthead | |
| 871 | \hbadness=5000\relax | |
| 872 | \gdef\EndMatter{}} | |
| 873 | ||
| 874 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 875 | %% | |
| 876 | %F \BeginningOfBook . . . . . . . . . . . . . . . . . . . . start the book | |
| 877 | %% | |
| 878 | \outer\def\BeginningOfBook#1{% | |
| 879 | \def\book{#1}% | |
| 880 | \pageno=-1% | |
| 881 | \pageno=1% | |
| 882 | \headlinefalse% | |
| 883 | \let\thechapter=\emptychapter% | |
| 884 | \def\lefthead{\it\chapname}% | |
| 885 | \let\righthead=\lefthead% | |
| 886 | } | |
| 887 | % | |
| 888 | % | |
| 889 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 890 | %% | |
| 891 | %F \UseReferences{<book-path>} . . . use references from book in <book-path> | |
| 892 | %% | |
| 893 | \outer\def\UseReferences#1{\begingroup\def\makelabel##1##2{\m@kelabel{##1}{##2}{}}\undoquotes | |
| 894 | \inputaux\labelin{#1/manual.lab}\endgroup | |
| 895 | } | |
| 896 | \outer\def\UseGapDocReferences#1{\begingroup\def\makelabel##1##2##3{\m@kelabel{##1}{##2}{##3}}\undoquotes | |
| 897 | \inputaux\labelin{#1/manual.lab}\endgroup | |
| 898 | } | |
| 899 | \outer\def\GAPDocLabFile#1{\def\makelabel##1##2##3{\m@kelabel{##1}{##2}{##3}}} | |
| 900 | % | |
| 901 | % | |
| 902 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 903 | %% | |
| 904 | %F \EndOfBook . . . . . . . . . . . . . . . . . . . . . . . . end the book | |
| 905 | %% | |
| 906 | \outer\def\EndOfBook{\vfill\supereject | |
| 907 | \immediate\write16{##} | |
| 908 | \immediate\closeout\citeout | |
| 909 | \immediate\write16{## Citations for BibTeX written on \jobname.aux.} | |
| 910 | \immediate\closeout\indexout | |
| 911 | \immediate\write16{## Index entries for makeindex written on \jobname.idx.} | |
| 912 | \immediate\closeout\secindout | |
| 913 | \immediate\write16{## Section index entries written on \jobname.six.} | |
| 914 | \immediate\closeout\labelout | |
| 915 | \immediate\write16{## Label definitions written on \jobname.lab.} | |
| 916 | \immediate\closeout\tocout | |
| 917 | \immediate\write16{## Table of contents written on \jobname.toc.} | |
| 918 | \immediate\write16{## Examples written to \jobname.example-XX.tst.} | |
| 919 | %\iflabmultdef\immediate\write16{## There were multiply-defined labels.}\fi | |
| 920 | \iflabundef\immediate\write16{## There were undefined labels or | |
| 921 | references.}\fi | |
| 922 | \iflabchanged\immediate\write16{## Labels have changed, run again. (Or | |
| 923 | they were multiply defined.)}\fi | |
| 924 | \immediate\write16{##} | |
| 925 | \end | |
| 926 | } | |
| 927 | % | |
| 928 | % | |
| 929 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 930 | %% | |
| 931 | %F \TableOfContents . . . . . . . . . . . . . . produce a table of contents | |
| 932 | %% | |
| 933 | % name of the chapter containing the table of contents | |
| 934 | \def\TOCHeader{Contents} | |
| 935 | ||
| 936 | % explanation at the beginning of the table of contents | |
| 937 | \def\TOCMatter{% | |
| 938 | } | |
| 939 | ||
| 940 | % macros for generating the table of contents | |
| 941 | %\newif\iffirstsec\firstsectrue | |
| 942 | \def\dotsfill{\leaders\hbox to12pt{\hss.\hss}\hfill} | |
| 943 | ||
| 944 | % produce the chapter "Contents" | |
| 945 | \outer\def\TableOfContents{\doChapter\TOCHeader{}% | |
| 946 | \TOCMatter | |
| 947 | \vskip 20pt | |
| 948 | \begingroup | |
| 949 | \rigidfalse | |
| 950 | \let!=\space | |
| 951 | \begindoublecolumns | |
| 952 | \inputaux\tocin{\jobname.toc}\vfill\eject | |
| 953 | \enddoublecolumns | |
| 954 | \endgroup | |
| 955 | } | |
| 956 | ||
| 957 | % a one column version of \TableOfContents for short manuals | |
| 958 | \outer\def\OneColumnTableOfContents{\doChapter\TOCHeader{}% | |
| 959 | \TOCMatter | |
| 960 | \vskip 20pt | |
| 961 | \begingroup | |
| 962 | \rigidfalse | |
| 963 | \let!=\space | |
| 964 | \inputaux\tocin{\jobname.toc}\vfill\eject | |
| 965 | \endgroup | |
| 966 | } | |
| 967 | ||
| 968 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 969 | %% | |
| 970 | %F \TitlePage{<text>} . . . . . . . . . . . . . . . . generate a title page | |
| 971 | %% | |
| 972 | \outer\long\def\TitlePage#1{% | |
| 973 | \null\vfill#1\null\vfill\eject | |
| 974 | } | |
| 975 | ||
| 976 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 977 | %% | |
| 978 | %F \Colophon{<text>} . . . . . . . . . . . . . . generate a colophon page | |
| 979 | %% | |
| 980 | \outer\long\def\Colophon#1{\doChapter{}{}% | |
| 981 | #1\null\vfill\eject | |
| 982 | } | |
| 983 | ||
| 984 | ||
| 985 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 986 | %% | |
| 987 | %F \Answers . . . . . . . . . . . . . produce the answers to the exercises | |
| 988 | %% | |
| 989 | % header for the answers | |
| 990 | \def\AnswersHeader{Answers to the Exercises} | |
| 991 | % | |
| 992 | % produce the chapter "Answers" | |
| 993 | \outer\def\Answers{\doChapter\AnswersHeader{}% | |
| 994 | \parindent\manindent | |
| 995 | \parskip 1ex plus 0.5ex minus 0.5ex | |
| 996 | \immediate\closeout\ans | |
| 997 | \input answers | |
| 998 | } | |
| 999 | ||
| 1000 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 1001 | %% | |
| 1002 | %F \Bibliography . . . . . . . . . . . . produce the chapter "Bibliography" | |
| 1003 | %% | |
| 1004 | % header for the bibliography | |
| 1005 | \def\BibHeader{Bibliography} | |
| 1006 | \newdimen\bibindent \bibindent=\manindent | |
| 1007 | ||
| 1008 | % produce the chapter bibliography | |
| 1009 | \outer\def\Bibliography{\EndMatter\doChapter\BibHeader{}% | |
| 1010 | \begingroup\undoquotes\frenchspacing | |
| 1011 | \parindent\bibindent | |
| 1012 | \pretolerance=5000 %badness allowed for hypenation | |
| 1013 | \tolerance=5000 %badness allowed before overfull boxes appear | |
| 1014 | \parskip 1ex plus 0.5ex minus 0.5ex | |
| 1015 | \def\begin##1##2{} \def\end##1{} | |
| 1016 | \let\newblock=\relax \let\em=\sl | |
| 1017 | \inputaux\citein{\jobname.bbl} | |
| 1018 | \endgroup | |
| 1019 | } | |
| 1020 | ||
| 1021 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 1022 | %% | |
| 1023 | %F \Index . . . . . . . . . . . . . . . . . . produce the chapter "Index" | |
| 1024 | %% | |
| 1025 | % header for the index | |
| 1026 | \def\IndexHeader{Index} | |
| 1027 | ||
| 1028 | % explanation at the beginning of the index | |
| 1029 | \def\IndexMatter{% | |
| 1030 | This index covers only this manual. | |
| 1031 | A page number in {\it italics} refers to a whole section which is devoted to | |
| 1032 | the indexed subject. Keywords are sorted with case and spaces ignored, | |
| 1033 | e.g., ```PermutationCharacter''' comes before ``permutation group''.% | |
| 1034 | } | |
| 1035 | ||
| 1036 | % kerning in full index after letter | |
| 1037 | \def\idxkern{\kern.3em} | |
| 1038 | ||
| 1039 | % produce the chapter index | |
| 1040 | \outer\def\Index{\EndMatter% | |
| 1041 | % get the proper bookmarking function | |
| 1042 | \global\let\setbookmarkind=\indexbookmark% | |
| 1043 | \doChapter\IndexHeader{}% | |
| 1044 | \IndexMatter | |
| 1045 | \bigskip | |
| 1046 | \begindoublecolumns | |
| 1047 | \pretolerance=5000 %badness allowed for hypenation | |
| 1048 | \tolerance=5000 %badness allowed before overfull boxes appear | |
| 1049 | \parindent 0pt \parskip 0pt \rightskip 0pt plus2em \emergencystretch 2em | |
| 1050 | \everypar{\hangindent\smallmanindent} | |
| 1051 | \def\par{\endgraf\leftskip 0pt} | |
| 1052 | \def\sub{\advance\leftskip by\smallmanindent} | |
| 1053 | \def\subsub{\advance\leftskip by2\smallmanindent} | |
| 1054 | \obeylines | |
| 1055 | \inputaux\indexin{\jobname.ind} | |
| 1056 | \enddoublecolumns | |
| 1057 | } | |
| 1058 | ||
| 1059 | % pseudo chapters used for authors, preface, copyright &c. | |
| 1060 | \def\PseudoInput#1#2#3{% | |
| 1061 | \vfill\eject% to ensure the pseudo-chapter no. doesn't get into headline | |
| 1062 | \advance\chapno by1\secno=0\subsecno=0 | |
| 1063 | \immediate\write\secindout{C #1.tex \thechapter. #2} | |
| 1064 | \label{#2}\label{#3}} % we do this for the benefit of the HTML manuals | |
| 1065 | ||
| 1066 | % some often-used LaTeX functions | |
| 1067 | \def\frac#1#2{{{#1}\over{#2}}} | |
| 1068 | ||
| 1069 | % as the etalchar gets written out in manual.lab, better make it nonfancy | |
| 1070 | % (otherwise something breaks). | |
| 1071 | \def\etalchar#1{$^{#1}$} | |
| 1072 | \def\etalchar#1{#1} | |
| 1073 | ||
| 1074 | % nasty trick to cope with the `newcommand' created by bibtex | |
| 1075 | \def\newcommand#1#2#3#4#5{} | |
| 1076 | ||
| 1077 | % URL stuff | |
| 1078 | \def\URL#1{\par\kernttindent\hbox{`#1'}\ifx\EndMatter\empty\else\qquad\fi} | |
| 1079 | \def\Mailto#1{\penalty-1000\hskip 0pt plus10cm\hbox{`#1'}} | |
| 1080 | ||
| 1081 | % ragged bottom will avoid large blank spaces | |
| 1082 | \raggedbottom | |
| 1083 | \frenchspacing | |
| 1084 | \vfuzz=2pt | |
| 1085 | ||
| 1086 | \catcode64=12% catcode of @ | |
| 1087 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 1088 | %% | |
| 1089 | %E | |
| 1090 | %% |
| 1 | 1 | %% |
| 2 | 2 | %W copyrigh.tex SONATA documentation |
| 3 | 3 | %W |
| 4 | %% | |
| 5 | %H @(#)$Id: copyrigh.tex,v 1.5 2012/11/07 13:26:29 stein Exp $ | |
| 6 | 4 | %% |
| 7 | 5 | %Y Copyright 2006, Institut fuer Algebra, Universitaet Linz, Austria |
| 8 | 6 | %% |
| 328 | 328 | [ f1, f2, f3, f2*f3, f1*f2*f4, f1*f3*f4, f1*f2*f3*f4 ] |
| 329 | 329 | \endexample |
| 330 | 330 | |
| 331 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% | |
| 332 | \Section{Nilpotency class} | |
| 333 | ||
| 334 | ||
| 335 | \>NilpotencyClass( <G> ) | |
| 336 | ||
| 337 | If <G> is a nilpotent group then the function `NilpotencyClass' returns the | |
| 338 | nilpotency class of <G> and `fail' otherwise. | |
| 339 | ||
| 340 | \beginexample | |
| 341 | gap> NilpotencyClass( SymmetricGroup( 7 ) ); | |
| 342 | fail | |
| 343 | gap> NilpotencyClass( GTW32_47 ); | |
| 344 | 3 | |
| 345 | \endexample | |
| 346 | 331 | |
| 347 | 332 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 348 | 333 | \Section{Scott length} |
| 0 | \bibstyle{alpha} | |
| 1 | \bibdata{sonata} | |
| 2 | \citation{thomaswood80:GT} | |
| 3 | \citation{scott69:TAOPMOAGATSOCPPGI} | |
| 4 | \citation{ecker98:OTNOPFONGOC2} | |
| 5 | \citation{Pilz:Nearrings} | |
| 6 | \citation{meldrum85:NATLWG} | |
| 7 | \citation{Clay:Nearrings} | |
| 8 | \citation{Pilz:Nearrings} | |
| 9 | \citation{meldrum85:NATLWG} | |
| 10 | \citation{Clay:Nearrings} | |
| 11 | \citation{aichingereckernoebauer00:TUOCINT} | |
| 12 | \citation{aichingerea00:CWN} | |
| 13 | \citation{Pilz:Nearrings} | |
| 14 | \citation{meldrum85:NATLWG} | |
| 15 | \citation{Clay:Nearrings} | |
| 16 | \citation{Wolf:Spaces} | |
| 17 | \citation{Mayr:Representations} | |
| 18 | \citation{Waehling:Fastkoerper} | |
| 19 | \citation{Clay:Nearrings} | |
| 20 | \citation{Clay:Nearrings} | |
| 21 | \citation{Clay:Nearrings} | |
| 22 | \citation{Clay:Nearrings} |
Binary diff not shown
| 0 | gap> G := GTW6_2; | |
| 1 | 6/2 | |
| 2 | gap> H := TWGroup( 4, 2 ); | |
| 3 | 4/2 | |
| 4 | gap> D := DirectProduct( G, H ); | |
| 5 | Group([ (1,2), (1,2,3), (4,5), (6,7) ]) | |
| 6 | gap> IdTWGroup( D ); | |
| 7 | [ 24, 4 ] | |
| 8 | gap> GroupList; | |
| 9 | [ 2/1, 3/1, 4/1, 4/2, 5/1, 6/1, 6/2, 7/1, 8/1, 8/2, 8/3, 8/4, 8/5, | |
| 10 | 9/1, 9/2, 10/1, 10/2, 11/1, 12/1, 12/2, 12/3, 12/4, 12/5, 13/1, | |
| 11 | 14/1, 14/2, 15/1, 16/1, 16/2, 16/3, 16/4, 16/5, 16/6, 16/7, 16/8, | |
| 12 | 16/9, 16/10, 16/11, 16/12, 16/13, 16/14, 17/1, 18/1, 18/2, 18/3, | |
| 13 | 18/4, 18/5, 19/1, 20/1, 20/2, 20/3, 20/4, 20/5, 21/1, 21/2, 22/1, | |
| 14 | 22/2, 23/1, 24/1, 24/2, 24/3, 24/4, 24/5, 24/6, 24/7, 24/8, 24/9, | |
| 15 | 24/10, 24/11, 24/12, 24/13, 24/14, 24/15, 25/1, 25/2, 26/1, 26/2, | |
| 16 | 27/1, 27/2, 27/3, 27/4, 27/5, 28/1, 28/2, 28/3, 28/4, 29/1, 30/1, | |
| 17 | 30/2, 30/3, 30/4, 31/1, 32/1, 32/2, 32/3, 32/4, 32/5, 32/6, 32/7, | |
| 18 | 32/8, 32/9, 32/10, 32/11, 32/12, 32/13, 32/14, 32/15, 32/16, 32/17, | |
| 19 | 32/18, 32/19, 32/20, 32/21, 32/22, 32/23, 32/24, 32/25, 32/26, | |
| 20 | 32/27, 32/28, 32/29, 32/30, 32/31, 32/32, 32/33, 32/34, 32/35, | |
| 21 | 32/36, 32/37, 32/38, 32/39, 32/40, 32/41, 32/42, 32/43, 32/44, | |
| 22 | 32/45, 32/46, 32/47, 32/48, 32/49, 32/50, 32/51 ] | |
| 23 | gap> G := GTW4_2; | |
| 24 | 4/2 | |
| 25 | gap> PrintTable( G ); | |
| 26 | Let: | |
| 27 | g0 := () | |
| 28 | g1 := (3,4) | |
| 29 | g2 := (1,2) | |
| 30 | g3 := (1,2)(3,4) | |
| 31 | ||
| 32 | * \ g0 g1 g2 g3 | |
| 33 | ------------------ | |
| 34 | g0 \ g0 g1 g2 g3 | |
| 35 | g1 \ g1 g0 g3 g2 | |
| 36 | g2 \ g2 g3 g0 g1 | |
| 37 | g3 \ g3 g2 g1 g0 | |
| 38 | ||
| 39 | gap> G := GTW4_2; | |
| 40 | 4/2 | |
| 41 | gap> SetSymbols( G, ["(0,0)","(1,0)","(0,1)","(1,1)"] ); | |
| 42 | gap> PrintTable( G ); | |
| 43 | Let: | |
| 44 | (0,0) := () | |
| 45 | (1,0) := (3,4) | |
| 46 | (0,1) := (1,2) | |
| 47 | (1,1) := (1,2)(3,4) | |
| 48 | ||
| 49 | * \ (0,0) (1,0) (0,1) (1,1) | |
| 50 | ----------------------------------- | |
| 51 | (0,0) \ (0,0) (1,0) (0,1) (1,1) | |
| 52 | (1,0) \ (1,0) (0,0) (1,1) (0,1) | |
| 53 | (0,1) \ (0,1) (1,1) (0,0) (1,0) | |
| 54 | (1,1) \ (1,1) (0,1) (1,0) (0,0) | |
| 55 | gap> G := TWGroup( 4, 2 ); | |
| 56 | 4/2 | |
| 57 | gap> Endomorphisms( G ); | |
| 58 | [ [ (1,2), (3,4) ] -> [ (), () ], [ (1,2), (3,4) ] -> [ (), (1,2) ], | |
| 59 | [ (1,2), (3,4) ] -> [ (), (3,4) ], [ (1,2), (3,4) ] -> [ (), (1,2)(3,4) ], | |
| 60 | [ (1,2), (3,4) ] -> [ (1,2), () ], [ (1,2), (3,4) ] -> [ (3,4), () ], | |
| 61 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), () ], [ (1,2), (3,4) ] -> [ (1,2), (1,2) ] | |
| 62 | , [ (1,2), (3,4) ] -> [ (3,4), (3,4) ], | |
| 63 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), (1,2)(3,4) ], | |
| 64 | [ (1,2), (3,4) ] -> [ (1,2), (3,4) ], | |
| 65 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), (3,4) ], | |
| 66 | [ (1,2), (3,4) ] -> [ (3,4), (1,2) ], | |
| 67 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), (1,2) ], | |
| 68 | [ (1,2), (3,4) ] -> [ (3,4), (1,2)(3,4) ], | |
| 69 | [ (1,2), (3,4) ] -> [ (1,2), (1,2)(3,4) ] ] | |
| 70 | gap> Automorphisms( GTW4_2 ); | |
| 71 | [ IdentityMapping( 4/2 ), [ (1,2), (3,4) ] -> [ (1,2)(3,4), (3,4) ], | |
| 72 | [ (1,2), (3,4) ] -> [ (3,4), (1,2) ], | |
| 73 | [ (3,4), (1,2) ] -> [ (1,2), (1,2)(3,4) ], | |
| 74 | [ (3,4), (1,2) ] -> [ (1,2)(3,4), (3,4) ], | |
| 75 | [ (3,4), (1,2) ] -> [ (1,2)(3,4), (1,2) ] ] | |
| 76 | gap> InnerAutomorphisms( AlternatingGroup( 4 ) ); | |
| 77 | [ ^(), ^(2,3,4), ^(2,4,3), ^(1,2)(3,4), ^(1,2,3), ^(1,2,4), | |
| 78 | ^(1,3,2), ^(1,3,4), ^(1,3)(2,4), ^(1,4,2), ^(1,4,3), ^(1,4)(2,3) ] | |
| 79 | gap> IsIsomorphicGroup( SymmetricGroup( 4 ), GTW24_12 ); | |
| 80 | true | |
| 81 | gap> Subgroups( TWGroup( 8, 4 ) ); | |
| 82 | [ Group(()), Group([ (1,3)(2,4) ]), Group([ (2,4) ]), Group([ (1,3) ]), | |
| 83 | Group([ (1,2)(3,4) ]), Group([ (1,4)(2,3) ]), Group([ (1,3)(2,4), (2,4) ]), | |
| 84 | Group([ (1,3)(2,4), (1,2,3,4) ]), Group([ (1,3)(2,4), (1,2)(3,4) ]), | |
| 85 | Group([ (1,3)(2,4), (2,4), (1,2,3,4) ]) ] | |
| 86 | gap> OneGeneratedNormalSubgroups( AlternatingGroup(4) ); | |
| 87 | [ Group([ (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ]) ] | |
| 88 | gap> D12 := DihedralGroup( 12 ); | |
| 89 | <pc group of size 12 with 3 generators> | |
| 90 | gap> s := Subgroups( D12 ); | |
| 91 | [ Group([ ]), Group([ f1 ]), Group([ f1*f3^2 ]), Group([ f1*f3 ]), | |
| 92 | Group([ f2*f3 ]), Group([ f1*f2 ]), Group([ f1*f2*f3^2 ]), | |
| 93 | Group([ f1*f2*f3 ]), Group([ f3 ]), Group([ f1, f2*f3 ]), | |
| 94 | Group([ f1*f3^2, f2*f3 ]), Group([ f1*f3, f2*f3 ]), | |
| 95 | Group([ f3, f1 ]), Group([ f3, f2 ]), Group([ f3, f1*f2 ]), | |
| 96 | Group([ f3, f1, f2 ]) ] | |
| 97 | gap> e := Endomorphisms( D12 );; | |
| 98 | gap> f := Filtered( s, sg -> IsInvariantUnderMaps( D12, sg, e ) ); | |
| 99 | [ Group([ ]), Group([ f3 ]), Group([ f3, f1, f2 ]) ] | |
| 100 | gap> IsCharacteristicInParent( Centre( GTW16_11 ) ); | |
| 101 | true | |
| 102 | gap> G := GTW6_2; | |
| 103 | 6/2 | |
| 104 | gap> S := Subgroup( G, [(1,2)] ); | |
| 105 | Group([ (1,2) ]) | |
| 106 | gap> IsFullinvariant( G, S ); | |
| 107 | false | |
| 108 | gap> IsFullinvariantInParent( Centre( GTW16_11 ) ); | |
| 109 | true | |
| 110 | gap> G := DihedralGroup( 16 ); | |
| 111 | <pc group of size 16 with 4 generators> | |
| 112 | gap> C := Centre( G ); | |
| 113 | Group([ f4 ]) | |
| 114 | gap> RepresentativesModNormalSubgroup( G, C ); | |
| 115 | [ <identity> of ..., f1, f2, f3, f2*f3, f1*f2*f4, f1*f3*f4, | |
| 116 | f1*f2*f3*f4 ] | |
| 117 | gap> G := DihedralGroup( 16 ); | |
| 118 | <pc group of size 16 with 4 generators> | |
| 119 | gap> C := Centre( G ); | |
| 120 | Group([ f4 ]) | |
| 121 | gap> NontrivialRepresentativesModNormalSubgroup( G, C ); | |
| 122 | [ f1, f2, f3, f2*f3, f1*f2*f4, f1*f3*f4, f1*f2*f3*f4 ] | |
| 123 | gap> ScottLength( GTW6_2 ); | |
| 124 | 2 | |
| 125 | gap> ScottLength( GTW16_11 ); | |
| 126 | 4 | |
| 127 | gap> D24 := DihedralGroup( 24 ); | |
| 128 | <pc group of size 24 with 4 generators> | |
| 129 | gap> D24p := AsPermGroup( D24 ); | |
| 130 | <permutation group of size 24 with 4 generators> | |
| 131 | gap> IsomorphismGroups( D24, D24p ); | |
| 132 | [ f1, f2, f3, f4 ] -> | |
| 133 | [ (1,17)(2,16)(3,18)(4,14)(5,13)(6,15)(7,20)(8,19)(9,21)(10,22)(11,24)(12,23), | |
| 134 | (1,11,4,9,2,12,5,7,3,10,6,8)(13,23,16,21,14,24,17,19,15,22,18,20), | |
| 135 | (1,4,2,5,3,6)(7,10,8,11,9,12)(13,16,14,17,15,18)(19,22,20,23,21,24), | |
| 136 | (1,2,3)(4,5,6)(7,8,9)(10,11,12)(13,14,15)(16,17,18)(19,20,21)(22,23,24) ] | |
| 137 | gap> C12 := CyclicGroup( 12 ); | |
| 138 | <pc group of size 12 with 3 generators> | |
| 139 | gap> AsPermGroup( C12 ); | |
| 140 | Group([ ( 1, 7, 4,10, 2, 8, 5,11, 3, 9, 6,12), | |
| 141 | ( 1, 4, 2, 5, 3, 6)( 7,10, 8,11, 9,12), | |
| 142 | ( 1, 2, 3)( 4, 5, 6)( 7, 8, 9)(10,11,12) ]) |
| 0 | gap> IsPairOfDicksonNumbers( 5, 4 ); | |
| 1 | true | |
| 2 | gap> DicksonNearFields( 5, 4 ); | |
| 3 | [ ExplicitMultiplicationNearRing ( <pc group of size 625 with | |
| 4 | 4 generators> , multiplication ), | |
| 5 | ExplicitMultiplicationNearRing ( <pc group of size 625 with | |
| 6 | 4 generators> , multiplication ) ] | |
| 7 | gap> NumberOfDicksonNearFields( 5, 4 ); | |
| 8 | 2 | |
| 9 | gap> ExceptionalNearFields( 25 ); | |
| 10 | [ ExplicitMultiplicationNearRing ( <pc group of size 25 with | |
| 11 | 2 generators> , multiplication ) ] | |
| 12 | gap> AllExceptionalNearFields(); | |
| 13 | [ ExplicitMultiplicationNearRing ( <pc group of size 25 with | |
| 14 | 2 generators> , multiplication ), | |
| 15 | ExplicitMultiplicationNearRing ( <pc group of size 49 with | |
| 16 | 2 generators> , multiplication ), | |
| 17 | ExplicitMultiplicationNearRing ( <pc group of size 121 with | |
| 18 | 2 generators> , multiplication ), | |
| 19 | ExplicitMultiplicationNearRing ( <pc group of size 121 with | |
| 20 | 2 generators> , multiplication ), | |
| 21 | ExplicitMultiplicationNearRing ( <pc group of size 529 with | |
| 22 | 2 generators> , multiplication ), | |
| 23 | ExplicitMultiplicationNearRing ( <pc group of size 841 with | |
| 24 | 2 generators> , multiplication ), | |
| 25 | ExplicitMultiplicationNearRing ( <pc group of size 3481 with | |
| 26 | 2 generators> , multiplication ) ] | |
| 27 | gap> C7 := CyclicGroup( 7 );; | |
| 28 | gap> i := GroupHomomorphismByFunction( C7, C7, x -> x^-1 );; | |
| 29 | gap> phi := Group( i );; | |
| 30 | gap> orbs := Orbits( phi, C7 ); | |
| 31 | [ [ <identity> of ... ], [ f1, f1^6 ], [ f1^2, f1^5 ], | |
| 32 | [ f1^3, f1^4 ] ] | |
| 33 | gap> # choose reps from the orbits | |
| 34 | gap> reps := [orbs[2][1], orbs[3][2]]; | |
| 35 | [ f1, f1^5 ] | |
| 36 | gap> n := PlanarNearRing( C7, phi, reps ); | |
| 37 | ExplicitMultiplicationNearRing ( <pc group of size 7 with | |
| 38 | 1 generators> , multiplication ) | |
| 39 | gap> C7 := CyclicGroup( 7 );; | |
| 40 | gap> i := GroupHomomorphismByFunction( C7, C7, x -> x^-1 );; | |
| 41 | gap> phi := Group( i );; | |
| 42 | gap> reps := OrbitRepresentativesForPlanarNearRing( C7, phi, 2 ); | |
| 43 | [ [ f1, f1^2 ], [ f1, f1^5 ] ] | |
| 44 | gap> n1 := PlanarNearRing( C7, phi, reps[1] );; | |
| 45 | gap> n2 := PlanarNearRing( C7, phi, reps[2] );; | |
| 46 | gap> IsIsomorphicNearRing( n1, n2 ); | |
| 47 | false | |
| 48 | gap> C9 := CyclicGroup( 9 );; | |
| 49 | gap> psi := GroupHomomorphismByFunction( C9, C9, x -> x^3 );; | |
| 50 | gap> Image( psi ); | |
| 51 | Group([ f2, <identity> of ... ]) | |
| 52 | gap> Image( psi ) = Kernel( psi ); | |
| 53 | true | |
| 54 | gap> a := GroupHomomorphismByFunction( C9, C9, x -> x^4 );; | |
| 55 | gap> phi := Group( a );; | |
| 56 | gap> Size( phi ); | |
| 57 | 3 | |
| 58 | gap> orbs := Orbits( phi, C9 ); | |
| 59 | [ [ <identity> of ... ], [ f2 ], [ f2^2 ], [ f1, f1*f2, f1*f2^2 ], | |
| 60 | [ f1^2, f1^2*f2^2, f1^2*f2 ] ] | |
| 61 | gap> # choose reps from the orbits outside of Image( psi ) | |
| 62 | gap> reps := [orbs[4][1], orbs[5][1]]; | |
| 63 | [ f1, f1^2 ] | |
| 64 | gap> n := WdNearRing( C9, psi, phi, reps ); | |
| 65 | ExplicitMultiplicationNearRing ( <pc group of size 9 with | |
| 66 | 2 generators> , multiplication ) |
| 0 | gap> points := [1..7];; | |
| 1 | gap> blocks := [[1,2,3],[1,4,5],[1,6,7],[2,4,7],[2,5,6],[3,5,7], | |
| 2 | > [3,4,6]];; | |
| 3 | gap> D := DesignFromPointsAndBlocks( points, blocks ); | |
| 4 | <an incidence structure with 7 points and 7 blocks> | |
| 5 | gap> M := [[1,0,1,1], | |
| 6 | > [1,1,0,0], | |
| 7 | > [1,1,1,0]];; | |
| 8 | gap> DesignFromIncidenceMat( M ); | |
| 9 | <an incidence structure with 3 points and 4 blocks> | |
| 10 | gap> n := LibraryNearRing( GTW9_2, 90 ); | |
| 11 | LibraryNearRing(9/2, 90) | |
| 12 | gap> IsPlanarNearRing( n ); | |
| 13 | true | |
| 14 | gap> D1 := DesignFromPlanarNearRing( n, "*" ); | |
| 15 | <a 2 - ( 9, 4, 3 ) nearring generated design> | |
| 16 | gap> D2 := DesignFromPlanarNearRing( n, " " ); | |
| 17 | <a 2 - ( 9, 5, 5 ) nearring generated design> | |
| 18 | gap> aux := FpfAutomorphismGroupsCyclic( [3,3], 4 ); | |
| 19 | [ [ [ f1, f2 ] -> [ f1*f2, f1*f2^2 ] ], | |
| 20 | <pc group of size 9 with 2 generators> ] | |
| 21 | gap> f := aux[1][1]; | |
| 22 | [ f1, f2 ] -> [ f1*f2, f1*f2^2 ] | |
| 23 | gap> phi := Group( f ); | |
| 24 | <group with 1 generators> | |
| 25 | gap> G := aux[2]; | |
| 26 | <pc group of size 9 with 2 generators> | |
| 27 | gap> D3 := DesignFromFerreroPair( G, phi, "*" ); | |
| 28 | <a 2 - ( 9, 4, 3 ) nearring generated design> | |
| 29 | gap> # D3 is actually isomorphic to D1 | |
| 30 | gap> n := LibraryNearRing( GTW9_1, 202 ); | |
| 31 | LibraryNearRing(9/1, 202) | |
| 32 | gap> IsWdNearRing( n ); | |
| 33 | true | |
| 34 | gap> DesignFromWdNearRing( n ); | |
| 35 | <a 1 - ( 9, 5, 10 ) nearring generated design> | |
| 36 | gap> D1; | |
| 37 | <a 2 - ( 9, 4, 3 ) nearring generated design> | |
| 38 | gap> PointsOfDesign( D1 ); | |
| 39 | [ (()), ((4,5,6)), ((4,6,5)), ((1,2,3)), ((1,2,3)(4,5,6)), | |
| 40 | ((1,2,3)(4,6,5)), ((1,3,2)), ((1,3,2)(4,5,6)), ((1,3,2)(4,6,5)) ] | |
| 41 | gap> PointsOfDesign( D1 ){[2,4]}; | |
| 42 | [ ((4,5,6)), ((1,2,3)) ] | |
| 43 | gap> # returns the points in position 2 and 4 | |
| 44 | gap> Length( BlocksOfDesign( D1 ) ); | |
| 45 | 18 | |
| 46 | gap> BlocksOfDesign( D1 ){[3]}; | |
| 47 | [ [ ((4,6,5)), (()), ((1,2,3)(4,5,6)), ((1,3,2)(4,5,6)) ] ] | |
| 48 | gap> # returns the block in position 3 as a list of points | |
| 49 | gap> DesignParameter( D1 ); | |
| 50 | [ 2, 9, 18, 8, 4, 3 ] | |
| 51 | gap> # t = 2, v = 9, b = 18, r = 8, k = 4, lambda = 3 | |
| 52 | gap> M1 := IncidenceMat( D1 ); | |
| 53 | [ [ 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1 ], | |
| 54 | [ 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1 ], | |
| 55 | [ 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 ], | |
| 56 | [ 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 ], | |
| 57 | [ 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1 ], | |
| 58 | [ 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0 ], | |
| 59 | [ 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0 ], | |
| 60 | [ 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0 ], | |
| 61 | [ 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0 ] ] | |
| 62 | gap> PrintIncidenceMat( D1 ); | |
| 63 | ..1.1.1..1.11..1.1 | |
| 64 | 1...1..11..1.11..1 | |
| 65 | 1.1....1.11..1.11. | |
| 66 | 1..1.1..1.1.1..1.1 | |
| 67 | .11..11...1..11..1 | |
| 68 | .1.11.1.1....1.11. | |
| 69 | 1..1.11..1.1..1.1. | |
| 70 | .11..1.11..11...1. | |
| 71 | .1.11..1.11.1.1... | |
| 72 | gap> BlockIntersectionNumbers( D1, 2 ); | |
| 73 | [ 0, 4, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1 ] | |
| 74 | gap> # the second has empty intersection with the first block | |
| 75 | gap> # and intersects all others in at most 2 points | |
| 76 | gap> IsCircularDesign( D1 ); | |
| 77 | true | |
| 78 | gap> IsPointIncidentBlock( D1, 3, 1 ); | |
| 79 | true | |
| 80 | gap> # point 3 is incident with block 1 | |
| 81 | gap> IsPointIncidentBlock( D1, 3, 2 ); | |
| 82 | false | |
| 83 | gap> PointsIncidentBlocks( D1, [1, 4] ); | |
| 84 | [ 4, 7 ] | |
| 85 | gap> # block 1 and block 4 are together incident with | |
| 86 | gap> # points 4 and 7 | |
| 87 | gap> BlocksIncidentPoints( D1, [2, 7] ); | |
| 88 | [ 1, 12, 15 ] | |
| 89 | gap> # point 2 and point 7 are together incident with | |
| 90 | gap> # blocks 1, 12, 15 | |
| 91 | gap> BlocksOfDesign( D1 ){last}; | |
| 92 | [ [ ((4,5,6)), ((4,6,5)), ((1,2,3)), ((1,3,2)) ], | |
| 93 | [ ((1,3,2)), ((1,3,2)(4,5,6)), (()), ((4,5,6)) ], | |
| 94 | [ ((1,3,2)(4,6,5)), ((1,3,2)), ((4,5,6)), ((1,2,3)(4,5,6)) ] ] | |
| 95 | gap> # the actual point sets of blocks 1, 12, and 15 | |
| 96 | gap> BlocksIncidentPoints( D1, [2, 3, 7] ); | |
| 97 | [ 1 ] | |
| 98 | gap> # points 2, 3, 7 are together incident with block 1 | |
| 99 | gap> PointsIncidentBlocks( D1, [1] ); | |
| 100 | [ 2, 3, 4, 7 ] | |
| 101 | gap> # block 1 is incident with points 2, 3, 4, 7 |
| 0 | gap> G := TWGroup( 24, 6 ); | |
| 1 | 24/6 | |
| 2 | gap> mul_l := function ( x, y ) return y; end; | |
| 3 | function ( x, y ) ... end | |
| 4 | gap> IsNearRingMultiplication( G, mul_l ); | |
| 5 | true | |
| 6 | gap> mul_r := function ( x, y ) return x; end; | |
| 7 | function ( x, y ) ... end | |
| 8 | gap> IsNearRingMultiplication( G, mul_r ); | |
| 9 | #I specified multiplication is not left distributive. | |
| 10 | false | |
| 11 | gap> IsNearRingMultiplication( G, mul_r, ["closed","ldistr"] ); | |
| 12 | true | |
| 13 | gap> G := CyclicGroup( 4 ); | |
| 14 | <pc group of size 4 with 2 generators> | |
| 15 | gap> GeneratorsOfGroup( G ); | |
| 16 | [ f1, f2 ] | |
| 17 | gap> a := last[1]; | |
| 18 | f1 | |
| 19 | gap> Order( a ); | |
| 20 | 4 | |
| 21 | gap> # a generates G indeed | |
| 22 | gap> elmlist := List( [0..3], x -> a^x ); | |
| 23 | [ <identity> of ..., f1, f2, f1*f2 ] | |
| 24 | gap> # Let: 1 := identity of ..., 2 := f1, 3 := f2, 4 := f1*f2 | |
| 25 | gap> # Consider the following multiplication table on G: | |
| 26 | gap> OT := [[1, 1, 1, 1], | |
| 27 | > [1, 4, 3, 2], | |
| 28 | > [1, 1, 1, 1], | |
| 29 | > [1, 2, 3, 4]];; | |
| 30 | gap> mul := NearRingMultiplicationByOperationTable( G, OT, elmlist ); | |
| 31 | function ( x, y ) ... end | |
| 32 | gap> IsNearRingMultiplication( G, mul ); | |
| 33 | true | |
| 34 | gap> n := ExplicitMultiplicationNearRing( GTW18_3, mul_l ); | |
| 35 | ExplicitMultiplicationNearRing ( 18/3 , multiplication ) | |
| 36 | gap> n = ExplicitMultiplicationNearRingNC( GTW18_3, mul_l ); | |
| 37 | true | |
| 38 | gap> n := ExplicitMultiplicationNearRingNC( GTW18_3, mul_l ); | |
| 39 | ExplicitMultiplicationNearRing ( 18/3 , multiplication ) | |
| 40 | gap> IsNearRing( n ); | |
| 41 | true | |
| 42 | gap> IsNearRing( GroupReduct( n ) ); | |
| 43 | false | |
| 44 | gap> IsExplicitMultiplicationNearRing( n ); | |
| 45 | true | |
| 46 | gap> n := ExplicitMultiplicationNearRingNC( GTW18_3, mul_l ); | |
| 47 | ExplicitMultiplicationNearRing ( 18/3 , multiplication ) | |
| 48 | gap> zero_mul := function ( x, y ) return (); end; | |
| 49 | function ( x, y ) ... end | |
| 50 | gap> z := ExplicitMultiplicationNearRingNC( GTW12_3, zero_mul ); | |
| 51 | ExplicitMultiplicationNearRing ( 12/3 , multiplication ) | |
| 52 | gap> d := DirectProductNearRing( n, z ); | |
| 53 | DirectProductNearRing( ExplicitMultiplicationNearRing ( 18/3 , multi\ | |
| 54 | plication ), ExplicitMultiplicationNearRing ( 12/3 , multiplication \ | |
| 55 | ) ) | |
| 56 | gap> IsExplicitMultiplicationNearRing( d ); | |
| 57 | true | |
| 58 | gap> n := ExplicitMultiplicationNearRingNC( CyclicGroup( 3 ), mul_l ); | |
| 59 | ExplicitMultiplicationNearRing ( <pc group of size 3 with | |
| 60 | 1 generators> , multiplication ) | |
| 61 | gap> SetSymbols( n, ["0","1","2"] ); | |
| 62 | gap> PrintTable( n ); | |
| 63 | Let: | |
| 64 | 0 := (<identity> of ...) | |
| 65 | 1 := (f1) | |
| 66 | 2 := (f1^2) | |
| 67 | ||
| 68 | + \ 0 1 2 | |
| 69 | ------------ | |
| 70 | 0 \ 0 1 2 | |
| 71 | 1 \ 1 2 0 | |
| 72 | 2 \ 2 0 1 | |
| 73 | ||
| 74 | * \ 0 1 2 | |
| 75 | ------------ | |
| 76 | 0 \ 0 1 2 | |
| 77 | 1 \ 0 1 2 | |
| 78 | 2 \ 0 1 2 | |
| 79 | gap> n := LibraryNearRing( GTW3_1, 4 ); | |
| 80 | LibraryNearRing(3/1, 4) | |
| 81 | gap> Symbols( n ); | |
| 82 | [ "n0", "n1", "n2" ] | |
| 83 | gap> SetSymbolsSupervised( n, | |
| 84 | ["apple", "banana", "coconut", "donut", "potato"] ); | |
| 85 | Warning: too many symbols ...ignoring the last 2 symbols | |
| 86 | gap> PrintTable( n, "m" ); | |
| 87 | ||
| 88 | * \ apple banana coconut | |
| 89 | ------------------------------------ | |
| 90 | apple \ apple apple apple | |
| 91 | banana \ apple banana coconut | |
| 92 | coconut \ apple banana coconut | |
| 93 | gap> mul_l := function ( x, y ) return y; end; | |
| 94 | function ( x, y ) ... end | |
| 95 | gap> n := ExplicitMultiplicationNearRingNC( GTW6_2, mul_l ); | |
| 96 | ExplicitMultiplicationNearRing ( 6/2 , multiplication ) | |
| 97 | gap> AsList( n ); | |
| 98 | [ (()), ((2,3)), ((1,2)), ((1,2,3)), ((1,3,2)), ((1,3)) ] | |
| 99 | gap> e := AsNearRingElement( n, (2,3) ); | |
| 100 | ((2,3)) | |
| 101 | gap> e in n; | |
| 102 | true | |
| 103 | gap> f := AsNearRingElement( n, (1,3) ); | |
| 104 | ((1,3)) | |
| 105 | gap> e + f; | |
| 106 | ((1,3,2)) | |
| 107 | gap> e * f; | |
| 108 | ((1,3)) | |
| 109 | gap> p := AsGroupReductElement( e ); | |
| 110 | (2,3) | |
| 111 | gap> IsPerm( p ); | |
| 112 | true | |
| 113 | gap> p + p; | |
| 114 | Error no method found for operation SUM with 2 arguments at | |
| 115 | Error( "no method found for operation ", NAME_FUNC( operation ), | |
| 116 | " with 2 arguments" ); | |
| 117 | Entering break read-eval-print loop, you can 'quit;' to quit to outer l\ | |
| 118 | oop, | |
| 119 | or you can return to continue | |
| 120 | brk> | |
| 121 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 122 | LibraryNearRing(6/2, 39) | |
| 123 | gap> e := Enumerator( n ); | |
| 124 | <enumerator of near ring> | |
| 125 | gap> e[1]; | |
| 126 | (()) | |
| 127 | gap> x := AsNearRingElement( n, (1,2,3) ); | |
| 128 | ((1,2,3)) | |
| 129 | gap> Position( e, x ); | |
| 130 | 2 | |
| 131 | gap> Length(e); | |
| 132 | 6 | |
| 133 | gap> l := AsList( n ); | |
| 134 | [ (()), ((2,3)), ((1,2)), ((1,2,3)), ((1,3,2)), ((1,3)) ] | |
| 135 | gap> e[3] = l[3]; | |
| 136 | false | |
| 137 | gap> AsSortedList( n ); | |
| 138 | [ (()), ((2,3)), ((1,2)), ((1,2,3)), ((1,3,2)), ((1,3)) ] | |
| 139 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 140 | LibraryNearRing(6/2, 39) | |
| 141 | gap> Random(n); | |
| 142 | ((1,3)) | |
| 143 | gap> n := ExplicitMultiplicationNearRingNC( GTW8_4, mul_l ); | |
| 144 | ExplicitMultiplicationNearRing ( 8/4 , multiplication ) | |
| 145 | gap> GeneratorsOfNearRing( n ); | |
| 146 | [ ((1,2,3,4)), ((2,4)) ] | |
| 147 | gap> n := LibraryNearRingWithOne( GTW24_3, 8 ); | |
| 148 | LibraryNearRingWithOne(24/3, 8) | |
| 149 | gap> Size(n); | |
| 150 | 24 | |
| 151 | gap> GroupReduct( LibraryNearRingWithOne( GTW24_3, 8 ) ); | |
| 152 | 24/3 | |
| 153 | gap> Endomorphisms ( LibraryNearRing( GTW12_4, 4 ) ) ; | |
| 154 | [ [ (1,2,4), (2,3,4) ] -> [ (), () ], | |
| 155 | [ (1,2,4), (2,3,4) ] -> [ (1,2,4), (2,3,4) ] ] | |
| 156 | gap> Length( Endomorphisms( GTW12_4 ) ); | |
| 157 | 33 | |
| 158 | gap> Automorphisms( LibraryNearRing( GTW12_4, 4 ) ); | |
| 159 | [ IdentityMapping( 12/4 ) ] | |
| 160 | gap> IsIsomorphicNearRing( MapNearRing( GTW2_1 ), | |
| 161 | > LibraryNearRingWithOne( GTW4_2, 5 ) ); | |
| 162 | true | |
| 163 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 164 | LibraryNearRing(12/4, 8) | |
| 165 | gap> SubNearRings( n ); | |
| 166 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 167 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3) ]) , multiplication ), | |
| 168 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 169 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 170 | ExplicitMultiplicationNearRing ( Group([ (1,2,4) ]) , multiplication ), | |
| 171 | ExplicitMultiplicationNearRing ( Group([ (1,3,2) ]) , multiplication ), | |
| 172 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 173 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3)(2,4) | |
| 174 | ]) , multiplication ), ExplicitMultiplicationNearRing ( Group( | |
| 175 | [ (1,4)(2,3), (1,3)(2,4), (2,3,4) ]) , multiplication ) ] | |
| 176 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 177 | LibraryNearRing(12/4, 8) | |
| 178 | gap> i := InvariantSubNearRings( n ); | |
| 179 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 180 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 181 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 182 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 183 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3)(2,4), (2,3,4) | |
| 184 | ]) , multiplication ) ] | |
| 185 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 186 | LibraryNearRing(12/4, 8) | |
| 187 | gap> S := Subgroup( GTW12_4, [ (1,2)(3,4) ] ); | |
| 188 | Group([ (1,2)(3,4) ]) | |
| 189 | gap> sn := SubNearRingBySubgroupNC( n, S ); | |
| 190 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ) | |
| 191 | gap> n := LibraryNearRingWithOne( GTW27_4, 5 ); | |
| 192 | LibraryNearRingWithOne(27/4, 5) | |
| 193 | gap> si := Filtered( SubNearRings( n ), s -> Identity( n ) in s ); | |
| 194 | [ ExplicitMultiplicationNearRing ( Group( | |
| 195 | [ (1,23,14)(2,13,6)(3,27,22)(4,18,9)(5,20,12)(7,16,26)(8,25,17)(10,21, | |
| 196 | 19)(11,24,15) ]) , multiplication ), | |
| 197 | ExplicitMultiplicationNearRing ( Group( | |
| 198 | [ (1,26,27)(2,19,20)(3,14,16)(4,24,25)(5,6,21)(7,22,23)(8,9,11)(10,12, | |
| 199 | 13)(15,17,18), (1,22,16)(2,12,21)(3,26,23)(4,17,11)(5,19,13)(6,20, | |
| 200 | 10)(7,14,27)(8,24,18)(9,25,15) ]) , multiplication ), | |
| 201 | ExplicitMultiplicationNearRing ( Group( | |
| 202 | [ (1,17,5)(2,22,8)(3,4,12)(6,26,18)(7,11,20)(9,19,23)(10,16,25)(13,14, | |
| 203 | 24)(15,21,27), (1,15,6)(2,7,9)(3,25,13)(4,10,14)(5,27,18)(8,20,23)(11, | |
| 204 | 19,22)(12,16,24)(17,21,26), (1,2,4)(3,6,11)(5,9,16)(7,13,17)(8,14, | |
| 205 | 21)(10,18,22)(12,15,23)(19,24,26)(20,25,27) ]) , multiplication ) ] | |
| 206 | gap> Intersection( si ); | |
| 207 | ExplicitMultiplicationNearRing ( Group( | |
| 208 | [ (1,23,14)(2,13,6)(3,27,22)(4,18,9)(5,20,12)(7,16,26)(8,25,17)(10,21,19)(11, | |
| 209 | 24,15) ]) , multiplication ) | |
| 210 | gap> Size( last ); | |
| 211 | 3 | |
| 212 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 213 | LibraryNearRing(12/4, 8) | |
| 214 | gap> Identity( n ); | |
| 215 | fail | |
| 216 | gap> One( n ); | |
| 217 | fail | |
| 218 | gap> n := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 219 | LibraryNearRingWithOne(24/4, 8) | |
| 220 | gap> Identity( n ); | |
| 221 | ((1,2,3,4,5,6)(7,8)) | |
| 222 | gap> One( n ); | |
| 223 | ((1,2,3,4,5,6)(7,8)) | |
| 224 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 225 | LibraryNearRing(12/4, 8) | |
| 226 | gap> IsNearRingWithOne( n ); | |
| 227 | false | |
| 228 | gap> n := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 229 | LibraryNearRingWithOne(24/4, 8) | |
| 230 | gap> Identity( n ); | |
| 231 | ((1,2,3,4,5,6)(7,8)) | |
| 232 | gap> IsNearRingWithOne( n ); | |
| 233 | false | |
| 234 | gap> n := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 235 | LibraryNearRingWithOne(24/4, 8) | |
| 236 | gap> NearRingUnits( n ); | |
| 237 | [ ((1,2,3,4,5,6)(7,8)), ((1,6,5,4,3,2)(7,8)) ] | |
| 238 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 239 | LibraryNearRing(12/4, 8) | |
| 240 | gap> IsNearRingWithOne( n ); | |
| 241 | false | |
| 242 | gap> Distributors( n ); | |
| 243 | [ (()), ((2,3,4)), ((2,4,3)), ((1,2)(3,4)), ((1,2,3)), ((1,2,4)), | |
| 244 | ((1,3,2)), ((1,3,4)), ((1,3)(2,4)), ((1,4,2)), ((1,4,3)), | |
| 245 | ((1,4)(2,3)) ] | |
| 246 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 247 | LibraryNearRing(12/4, 8) | |
| 248 | gap> DistributiveElements( n ); | |
| 249 | [ (()) ] | |
| 250 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 251 | LibraryNearRing(12/4, 8) | |
| 252 | gap> IsDistributiveNearRing( n ); | |
| 253 | false | |
| 254 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 255 | LibraryNearRing(12/4, 8) | |
| 256 | gap> ZeroSymmetricElements( n ); | |
| 257 | [ (()), ((2,3,4)), ((2,4,3)), ((1,2)(3,4)), ((1,2,3)), ((1,2,4)), | |
| 258 | ((1,3,2)), ((1,3,4)), ((1,3)(2,4)), ((1,4,2)), ((1,4,3)), | |
| 259 | ((1,4)(2,3)) ] | |
| 260 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 261 | LibraryNearRing(12/4, 8) | |
| 262 | gap> IdempotentElements( n ); | |
| 263 | [ (()), ((1,4)(2,3)) ] | |
| 264 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 265 | LibraryNearRing(12/4, 8) | |
| 266 | gap> NilpotentElements( n ); | |
| 267 | [ [ (()), 1 ], [ ((2,3,4)), 2 ], [ ((2,4,3)), 2 ], | |
| 268 | [ ((1,2)(3,4)), 2 ], [ ((1,2,3)), 2 ], [ ((1,2,4)), 2 ], | |
| 269 | [ ((1,3,2)), 2 ], [ ((1,3,4)), 2 ], [ ((1,4,2)), 2 ], | |
| 270 | [ ((1,4,3)), 2 ] ] | |
| 271 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 272 | LibraryNearRing(12/4, 8) | |
| 273 | gap> QuasiregularElements( n ); | |
| 274 | [ (()), ((2,3,4)), ((2,4,3)), ((1,2)(3,4)), ((1,2,3)), ((1,2,4)), | |
| 275 | ((1,3,2)), ((1,3,4)), ((1,3)(2,4)), ((1,4,2)), ((1,4,3)) ] | |
| 276 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 277 | LibraryNearRing(12/4, 8) | |
| 278 | gap> RegularElements( n ); | |
| 279 | [ (()), ((1,3)(2,4)), ((1,4)(2,3)) ] | |
| 280 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 281 | LibraryNearRing(12/4, 8) | |
| 282 | gap> IsAbelianNearRing( n ); | |
| 283 | false | |
| 284 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 285 | LibraryNearRing(12/4, 8) | |
| 286 | gap> IsAbstractAffineNearRing( n ); | |
| 287 | false | |
| 288 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 289 | LibraryNearRing(12/4, 8) | |
| 290 | gap> IsBooleanNearRing( n ); | |
| 291 | false | |
| 292 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 293 | LibraryNearRing(12/4, 8) | |
| 294 | gap> IsNilNearRing( n ); | |
| 295 | false | |
| 296 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 297 | LibraryNearRing(12/4, 8) | |
| 298 | gap> IsNilpotentNearRing( n ); | |
| 299 | false | |
| 300 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 301 | LibraryNearRing(12/4, 8) | |
| 302 | gap> IsNilpotentFreeNearRing( n ); | |
| 303 | false | |
| 304 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 305 | LibraryNearRing(12/4, 8) | |
| 306 | gap> IsCommutative( n ); | |
| 307 | false | |
| 308 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 309 | LibraryNearRing(12/4, 8) | |
| 310 | gap> IsDgNearRing( n ); | |
| 311 | false | |
| 312 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 313 | LibraryNearRing(12/4, 8) | |
| 314 | gap> IsIntegralNearRing( n ); | |
| 315 | false | |
| 316 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 317 | LibraryNearRing(12/4, 8) | |
| 318 | gap> IsPrimeNearRing( n ); | |
| 319 | true | |
| 320 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 321 | LibraryNearRing(12/4, 8) | |
| 322 | gap> IsQuasiregularNearRing( n ); | |
| 323 | false | |
| 324 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 325 | LibraryNearRing(12/4, 8) | |
| 326 | gap> IsRegularNearRing( n ); | |
| 327 | false | |
| 328 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 329 | LibraryNearRing(12/4, 8) | |
| 330 | gap> IsNearField( n ); | |
| 331 | false | |
| 332 | gap> n := LibraryNearRing( GTW9_2, 90 ); | |
| 333 | LibraryNearRing(9/2, 90) | |
| 334 | gap> IsPlanarNearRing( n ); | |
| 335 | true | |
| 336 | gap> nr := LibraryNearRing( GTW9_1, 185 ); | |
| 337 | LibraryNearRing(9/1, 185) | |
| 338 | gap> IsWdNearRing( nr ); | |
| 339 | true |
| 0 | gap> l := AllLibraryNearRings( GTW3_1 ); | |
| 1 | [ LibraryNearRing(3/1, 1), LibraryNearRing(3/1, 2), | |
| 2 | LibraryNearRing(3/1, 3), LibraryNearRing(3/1, 4), | |
| 3 | LibraryNearRing(3/1, 5) ] | |
| 4 | gap> Filtered( l, IsNearField ); | |
| 5 | [ LibraryNearRing(3/1, 3) ] | |
| 6 | gap> NumberLibraryNearRings( GTW14_2 ); | |
| 7 | 1821 | |
| 8 | gap> LN14_2_1234 := LibraryNearRing( GTW14_2, 1234 ); | |
| 9 | LibraryNearRing(14/2, 1234) | |
| 10 | gap> NumberLibraryNearRingsWithOne( GTW24_6 ); | |
| 11 | 0 | |
| 12 | gap> NumberLibraryNearRingsWithOne( GTW24_4 ); | |
| 13 | 10 | |
| 14 | gap> LNwI24_4_8 := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 15 | LibraryNearRingWithOne(24/4, 8) | |
| 16 | gap> AllLibraryNearRingsWithOne( GTW24_6 ); | |
| 17 | [ ] | |
| 18 | gap> p := PolynomialNearRing( GTW4_2 ); | |
| 19 | PolynomialNearRing( 4/2 ) | |
| 20 | gap> IdLibraryNearRing( p ); | |
| 21 | [ 8/3, 833 ] | |
| 22 | gap> n := LibraryNearRing( GTW3_1, 4 ); | |
| 23 | LibraryNearRing(3/1, 4) | |
| 24 | gap> d := DirectProductNearRing( n, n ); | |
| 25 | DirectProductNearRing( LibraryNearRing(3/1, 4), LibraryNearRing(3/1, 4)\ | |
| 26 | ) | |
| 27 | gap> IdLibraryNearRing( d ); | |
| 28 | [ 9/2, 220 ] | |
| 29 | gap> l := LibraryNearRingWithOne( GTW12_3, 1 ); | |
| 30 | LibraryNearRingWithOne(12/3, 1) | |
| 31 | gap> IdLibraryNearRing( l ); #this command requires time and memory!!! | |
| 32 | [ 12/3, 37984 ] | |
| 33 | gap> IdLibraryNearRingWithOne( l ); | |
| 34 | [ 12/3, 1 ] | |
| 35 | gap> IsLibraryNearRing( LNwI24_4_8 ); | |
| 36 | true |
| 0 | gap> G := GTW4_2; | |
| 1 | 4/2 | |
| 2 | gap> t1 := EndoMappingByPositionList ( G, [1, 2, 4, 4] ); | |
| 3 | <mapping: 4/2 -> 4/2 > | |
| 4 | gap> t2 := EndoMappingByFunction ( GTW8_2, g -> g^-1 ); | |
| 5 | <mapping: 8/2 -> 8/2 > | |
| 6 | gap> IsGroupHomomorphism ( t2 ); | |
| 7 | true | |
| 8 | gap> t3 := EndoMappingByFunction ( GTW6_2, g -> g^-1 ); | |
| 9 | <mapping: 6/2 -> 6/2 > | |
| 10 | gap> IsGroupHomomorphism ( t3 ); | |
| 11 | false | |
| 12 | gap> G1 := Group ((1,2,3), (1, 2)); | |
| 13 | Group([ (1,2,3), (1,2) ]) | |
| 14 | gap> G2 := Group ((2,3,4), (2, 3)); | |
| 15 | Group([ (2,3,4), (2,3) ]) | |
| 16 | gap> f1 := IsomorphismGroups ( G1, G2 ); | |
| 17 | [ (1,2,3), (1,2) ] -> [ (2,3,4), (2,3) ] | |
| 18 | gap> f2 := IsomorphismGroups ( G2, G1 ); | |
| 19 | [ (2,3,4), (2,3) ] -> [ (1,2,3), (1,2) ] | |
| 20 | gap> AsEndoMapping ( CompositionMapping ( f1, f2 ) ); | |
| 21 | <mapping: Group( [ (2,3,4), (2,3) ] ) -> Group( [ (2,3,4), (2,3) | |
| 22 | ] ) > | |
| 23 | gap> m := IdentityEndoMapping ( GTW6_2 ); | |
| 24 | <mapping: 6/2 -> 6/2 > | |
| 25 | gap> AsGroupGeneralMappingByImages ( m ); | |
| 26 | [ (1,2), (1,2,3) ] -> [ (1,2), (1,2,3) ] | |
| 27 | gap> IsEndoMapping ( InnerAutomorphisms ( GTW6_2 ) [3] ); | |
| 28 | true | |
| 29 | gap> AsList ( UnderlyingRelation ( IdentityEndoMapping ( Group ((1,2,3,4)) ) ) ); | |
| 30 | [ Tuple( [ (), () ] ), Tuple( [ (1,2,3,4), (1,2,3,4) ] ), | |
| 31 | Tuple( [ (1,3)(2,4), (1,3)(2,4) ] ), Tuple( [ (1,4,3,2), (1,4,3,2) ] ) | |
| 32 | ] | |
| 33 | gap> C3 := CyclicGroup (3); | |
| 34 | <pc group of size 3 with 1 generators> | |
| 35 | gap> m := ConstantEndoMapping (C3, AsSortedList (C3) [2]); | |
| 36 | MappingByFunction( <pc group of size 3 with | |
| 37 | 1 generators>, <pc group of size 3 with | |
| 38 | 1 generators>, function( x ) ... end ) | |
| 39 | gap> List (AsList (C3), x -> Image (m, x)); | |
| 40 | [ f1, f1, f1 ] | |
| 41 | gap> IsIdentityEndoMapping (EndoMappingByFunction ( | |
| 42 | > AlternatingGroup ( [1..5] ), x -> x^31)); | |
| 43 | true | |
| 44 | gap> C3 := CyclicGroup ( 3 ); | |
| 45 | <pc group of size 3 with 1 generators> | |
| 46 | gap> IsConstantEndoMapping ( EndoMappingByFunction ( C3, x -> x^3 )); | |
| 47 | true | |
| 48 | gap> G := Group ( (1,2,3), (1,2) ); | |
| 49 | Group([ (1,2,3), (1,2) ]) | |
| 50 | gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^3)); | |
| 51 | false | |
| 52 | gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^7)); | |
| 53 | true | |
| 54 | gap> t1 := ConstantEndoMapping ( GTW2_1, ()); | |
| 55 | MappingByFunction( 2/1, 2/1, function( x ) ... end ) | |
| 56 | gap> t2 := ConstantEndoMapping (GTW2_1, (1, 2)); | |
| 57 | MappingByFunction( 2/1, 2/1, function( x ) ... end ) | |
| 58 | gap> List ( AsList ( GTW2_1 ), x -> Image ( t1 * t2, x )); | |
| 59 | [ (1,2), (1,2) ] | |
| 60 | gap> G := SymmetricGroup ( 3 ); | |
| 61 | Sym( [ 1 .. 3 ] ) | |
| 62 | gap> invertingOnG := EndoMappingByFunction ( G, x -> x^-1 ); | |
| 63 | <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( | |
| 64 | [ 1 .. 3 ] ) > | |
| 65 | gap> identityOnG := IdentityEndoMapping (G); | |
| 66 | <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( | |
| 67 | [ 1 .. 3 ] ) > | |
| 68 | gap> AsSortedList ( G ); | |
| 69 | [ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ] | |
| 70 | gap> List ( AsSortedList (G), | |
| 71 | > x -> Image ( identityOnG * invertingOnG, x )); | |
| 72 | [ (), (2,3), (1,2), (1,3,2), (1,2,3), (1,3) ] | |
| 73 | gap> List ( AsSortedList (G), | |
| 74 | > x -> Image ( identityOnG + invertingOnG, x )); | |
| 75 | [ (), (), (), (), (), () ] | |
| 76 | gap> IsIdentityEndoMapping ( - invertingOnG ); | |
| 77 | true | |
| 78 | gap> - invertingOnG = identityOnG; | |
| 79 | true | |
| 80 | gap> G := SymmetricGroup ( 3 ); | |
| 81 | Sym( [ 1 .. 3 ] ) | |
| 82 | gap> m := ConstantEndoMapping (G, (1,2,3)) + IdentityEndoMapping( G ); | |
| 83 | MappingByFunction( Sym( [ 1 .. 3 ] ), Sym( [ 1 .. 3 ] ), function( g ) ... end ) | |
| 84 | gap> PrintArray( GraphOfMapping( m ) ); | |
| 85 | [ [ (), (1,2,3) ], | |
| 86 | [ (2,3), (1,3) ], | |
| 87 | [ (1,2), (2,3) ], | |
| 88 | [ (1,2,3), (1,3,2) ], | |
| 89 | [ (1,3,2), () ], | |
| 90 | [ (1,3), (1,2) ] ] | |
| 91 | gap> G := SymmetricGroup ( 3 ); | |
| 92 | Sym( [ 1 .. 3 ] ) | |
| 93 | gap> p := Random( PolynomialNearRing( G ) ); | |
| 94 | <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( [ 1 .. 3 ] ) > | |
| 95 | gap> PrintAsTerm( p ); | |
| 96 | g1 - x - 2 * g1 - g2 - x - g1 - g2 + g1 - x - 2 * g1 - | |
| 97 | g2 - x - g1 - g2 - 3 * x + g1 | |
| 98 | gap> GeneratorsOfGroup( G ); | |
| 99 | [ (1,2,3), (1,2) ] |
| 0 | gap> g := AlternatingGroup ( 4 ); | |
| 1 | Alt( [ 1 .. 4 ] ) | |
| 2 | gap> AsSortedList ( g ); | |
| 3 | [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), | |
| 4 | (1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ] | |
| 5 | gap> t := EndoMappingByPositionList ( g, [1,3,4,5,2,1,1,1,1,1,1,1] ); | |
| 6 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 7 | [ 1 .. 4 ] ) > | |
| 8 | gap> m := TransformationNearRingByGenerators ( g, [t] ); | |
| 9 | TransformationNearRingByGenerators( | |
| 10 | [ <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 11 | [ 1 .. 4 ] ) > ]) | |
| 12 | gap> Size (m); # may take a few moments | |
| 13 | 20736 | |
| 14 | gap> IsCommutative ( m ); | |
| 15 | false | |
| 16 | gap> G := SymmetricGroup(3);; | |
| 17 | gap> endos := Endomorphisms ( G ); | |
| 18 | [ [ (1,2,3), (1,2) ] -> [ (), () ], [ (1,2,3), (1,2) ] -> [ (), (2,3) ], | |
| 19 | [ (1,2,3), (1,2) ] -> [ (), (1,2) ], [ (1,2,3), (1,2) ] -> [ (), (1,3) ], | |
| 20 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (2,3) ], | |
| 21 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (2,3) ], | |
| 22 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,2) ], | |
| 23 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,2) ], | |
| 24 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,3) ], | |
| 25 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,3) ] ] | |
| 26 | gap> Endo := TransformationNearRingByAdditiveGenerators ( G, endos ); | |
| 27 | < transformation nearring with 10 generators > | |
| 28 | gap> Size( Endo ); | |
| 29 | 54 | |
| 30 | gap> m := MapNearRing ( GTW32_12 ); | |
| 31 | TransformationNearRing(32/12) | |
| 32 | gap> Size ( m ); | |
| 33 | 1461501637330902918203684832716283019655932542976 | |
| 34 | gap> NearRingIdeals ( m ); | |
| 35 | [ < nearring ideal >, < nearring ideal > ] | |
| 36 | gap> g := CyclicGroup ( 4 ); | |
| 37 | <pc group of size 4 with 2 generators> | |
| 38 | gap> m := MapNearRing ( g ); | |
| 39 | TransformationNearRing(<pc group of size 4 with 2 generators>) | |
| 40 | gap> gens := Filtered ( AsList ( m ), | |
| 41 | > f -> IsFullTransformationNearRing ( | |
| 42 | > TransformationNearRingByGenerators ( g, [ f ] )));; | |
| 43 | gap> Length(gens); | |
| 44 | 12 | |
| 45 | gap> P := PolynomialNearRing ( GTW16_6 ); | |
| 46 | PolynomialNearRing( 16/6 ) | |
| 47 | gap> Size ( P ); | |
| 48 | 256 | |
| 49 | gap> ES4 := EndomorphismNearRing ( SymmetricGroup ( 4 ) ); | |
| 50 | EndomorphismNearRing( Sym( [ 1 .. 4 ] ) ) | |
| 51 | gap> Size ( ES4 ); | |
| 52 | 927712935936 | |
| 53 | gap> A := AutomorphismNearRing ( DihedralGroup ( 8 ) ); | |
| 54 | AutomorphismNearRing( <pc group of size 8 with 3 generators> ) | |
| 55 | gap> Length(NearRingRightIdeals ( A )); | |
| 56 | 28 | |
| 57 | gap> Size (A); | |
| 58 | 32 | |
| 59 | gap> I := InnerAutomorphismNearRing ( AlternatingGroup ( 4 ) ); | |
| 60 | InnerAutomorphismNearRing( Alt( [ 1 .. 4 ] ) ) | |
| 61 | gap> Size ( I ); | |
| 62 | 3072 | |
| 63 | gap> m := Enumerator( I )[1000]; | |
| 64 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( [ 1 .. 4 ] ) > | |
| 65 | gap> graph := List ( AsList ( AlternatingGroup ( 4 ) ), | |
| 66 | > x -> [x, Image (m, x)] ); | |
| 67 | [ [ (), () ], [ (2,3,4), (1,4)(2,3) ], [ (2,4,3), (1,4)(2,3) ], | |
| 68 | [ (1,2)(3,4), (1,2)(3,4) ], [ (1,2,3), (1,3)(2,4) ], | |
| 69 | [ (1,2,4), (1,4)(2,3) ], [ (1,3,2), (1,4)(2,3) ], [ (1,3,4), (1,2)(3,4) ], | |
| 70 | [ (1,3)(2,4), (1,3)(2,4) ], [ (1,4,2), () ], [ (1,4,3), (1,4)(2,3) ], | |
| 71 | [ (1,4)(2,3), (1,4)(2,3) ] ] | |
| 72 | gap> autos := Automorphisms ( GTW8_4 ); | |
| 73 | [ IdentityMapping( 8/4 ), ^(2,4), | |
| 74 | [ (1,2,3,4), (2,4) ] -> [ (1,4,3,2), (1,2)(3,4) ], | |
| 75 | [ (1,2,3,4), (2,4) ] -> [ (1,2,3,4), (1,2)(3,4) ], ^(1,4)(2,3), | |
| 76 | ^(1,2,3,4), [ (1,2,3,4), (2,4) ] -> [ (1,2,3,4), (1,4)(2,3) ], | |
| 77 | [ (1,4)(2,3), (1,4,3,2) ] -> [ (2,4), (1,2,3,4) ] ] | |
| 78 | gap> C := CentralizerNearRing ( GTW8_4, autos ); | |
| 79 | CentralizerNearRing( 8/4, ... ) | |
| 80 | gap> C0 := ZeroSymmetricPart ( C ); | |
| 81 | < transformation nearring with 4 generators > | |
| 82 | gap> Size ( C0 ); | |
| 83 | 32 | |
| 84 | gap> Is := NearRingIdeals ( C0 ); | |
| 85 | [ < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 86 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 87 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 88 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 89 | < nearring ideal > ] | |
| 90 | gap> List (Is, Size); | |
| 91 | [ 1, 2, 4, 2, 4, 8, 8, 16, 4, 8, 16, 16, 32 ] | |
| 92 | gap> G := GTW16_8; | |
| 93 | 16/8 | |
| 94 | gap> U := First ( NormalSubgroups ( G ), | |
| 95 | > x -> Size (x) = 2 ); | |
| 96 | Group([ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) | |
| 97 | gap> HGU := RestrictedEndomorphismNearRing (G, U); | |
| 98 | RestrictedEndomorphismNearRing( 16/8, Group( | |
| 99 | [ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) ) | |
| 100 | gap> Size (HGU); | |
| 101 | 8 | |
| 102 | gap> IsDistributiveNearRing ( HGU ); | |
| 103 | true | |
| 104 | gap> Filtered ( AsList ( HGU), | |
| 105 | > x -> x = x * x ); | |
| 106 | [ <mapping: 16/8 -> 16/8 > ] | |
| 107 | gap> P := PolynomialNearRing ( GTW8_5 ); | |
| 108 | PolynomialNearRing( 8/5 ) | |
| 109 | gap> L := LocalInterpolationNearRing ( P, 2 ); | |
| 110 | LocalInterpolationNearRing( PolynomialNearRing( 8/5 ), 2 ) | |
| 111 | gap> Size ( L ) / Size ( P ); | |
| 112 | 16 | |
| 113 | gap> Gamma ( PolynomialNearRing ( CyclicGroup ( 25 ) ) ); | |
| 114 | <pc group of size 25 with 2 generators> | |
| 115 | gap> IsCyclic (last); | |
| 116 | true | |
| 117 | gap> L := LibraryNearRing (GTW8_3, 12); | |
| 118 | LibraryNearRing(8/3, 12) | |
| 119 | gap> Lt := AsTransformationNearRing ( L ); | |
| 120 | < transformation nearring with 3 generators > | |
| 121 | gap> Gamma ( Lt ); | |
| 122 | 8/3 x C_2 | |
| 123 | gap> P := PolynomialNearRing ( GTW4_2 ); | |
| 124 | PolynomialNearRing( 4/2 ) | |
| 125 | gap> n := AsExplicitMultiplicationNearRing ( P ); | |
| 126 | ExplicitMultiplicationNearRing ( Group( | |
| 127 | [ ( 1, 2)( 5, 6)( 9,10)(13,14), ( 3, 4)( 7, 8)(11,12)(15,16), | |
| 128 | ( 7, 8)( 9,10)(13,14)(15,16) ]) , multiplication ) | |
| 129 | gap> G := SymmetricGroup ( 4 ); | |
| 130 | Sym( [ 1 .. 4 ] ) | |
| 131 | gap> V := First ( NormalSubgroups ( G ), x -> Size ( x ) = 4 ); | |
| 132 | Group([ (1,4)(2,3), (1,3)(2,4) ]) | |
| 133 | gap> P := InnerAutomorphismNearRing ( G ); | |
| 134 | InnerAutomorphismNearRing( Sym( [ 1 .. 4 ] ) ) | |
| 135 | gap> N := NoetherianQuotient ( P, V, G ); | |
| 136 | NoetherianQuotient( Group([ (1,4)(2,3), (1,3)(2,4) ]) ,Sym( | |
| 137 | [ 1 .. 4 ] ) ) | |
| 138 | gap> Size ( P ) / Size ( N ); | |
| 139 | 54 | |
| 140 | gap> G := GTW8_4; | |
| 141 | 8/4 | |
| 142 | gap> P := PolynomialNearRing (G); | |
| 143 | PolynomialNearRing( 8/4 ) | |
| 144 | gap> A := TrivialSubgroup (G); | |
| 145 | Group(()) | |
| 146 | gap> B := DerivedSubgroup (G); | |
| 147 | Group([ (1,3)(2,4) ]) | |
| 148 | gap> C := G; | |
| 149 | 8/4 | |
| 150 | gap> I := CongruenceNoetherianQuotient (P, A, B, C); | |
| 151 | < nearring ideal > | |
| 152 | gap> Size (P/I); | |
| 153 | 2 | |
| 154 | gap> G := GTW8_4; | |
| 155 | 8/4 | |
| 156 | gap> I := InnerAutomorphismNearRing (G); | |
| 157 | InnerAutomorphismNearRing( 8/4 ) | |
| 158 | gap> A := TrivialSubgroup (G); | |
| 159 | Group(()) | |
| 160 | gap> B := DerivedSubgroup (G); | |
| 161 | Group([ (1,3)(2,4) ]) | |
| 162 | gap> C := G; | |
| 163 | 8/4 | |
| 164 | gap> j := CongruenceNoetherianQuotientForInnerAutomorphismNearRings (I,A,B,C); | |
| 165 | < nearring ideal > | |
| 166 | gap> Size (I/j); | |
| 167 | 2 | |
| 168 | gap> g := GTW8_4; | |
| 169 | 8/4 | |
| 170 | gap> P := PolynomialNearRing ( g ); | |
| 171 | PolynomialNearRing( 8/4 ) | |
| 172 | gap> Zp := ZeroSymmetricPart ( P ); | |
| 173 | < transformation nearring with 4 generators > | |
| 174 | gap> InnerAutomorphismNearRing ( g ) = Zp; | |
| 175 | true |
| 0 | gap> n := LibraryNearRing( GTW8_4, 12 ); | |
| 1 | LibraryNearRing(8/4, 12) | |
| 2 | gap> e := AsNearRingElement( n, (1,3)(2,4) ); | |
| 3 | ((1,3)(2,4)) | |
| 4 | gap> r := NearRingRightIdealByGenerators( n, [e] ); | |
| 5 | < nearring right ideal > | |
| 6 | gap> l := NearRingLeftIdealByGenerators( n, [e] ); | |
| 7 | < nearring left ideal > | |
| 8 | gap> i := NearRingIdealByGenerators( n, [e] ); | |
| 9 | < nearring ideal > | |
| 10 | gap> r = i; | |
| 11 | true | |
| 12 | gap> l = i; | |
| 13 | false | |
| 14 | gap> l = r; | |
| 15 | false | |
| 16 | gap> a := GroupReduct( n ); | |
| 17 | 8/4 | |
| 18 | gap> nsgps := NormalSubgroups( a ); | |
| 19 | [ Group(()), Group([ (1,3)(2,4) ]), | |
| 20 | Group([ (1,3)(2,4), (1,2)(3,4) ]), Group([ (1,3)(2,4), (2,4) ]), | |
| 21 | Group([ (1,2,3,4), (1,3)(2,4) ]), 8/4 ] | |
| 22 | gap> l := Filtered( nsgps, | |
| 23 | > s -> IsSubgroupNearRingRightIdeal( n, s ) ); | |
| 24 | [ Group(()), Group([ (1,3)(2,4), (2,4) ]), 8/4 ] | |
| 25 | gap> l := List( l, | |
| 26 | > s -> NearRingRightIdealBySubgroupNC( n, s ) ); | |
| 27 | [ < nearring right ideal >, < nearring right ideal >, | |
| 28 | < nearring right ideal > ] | |
| 29 | gap> NearRingIdeals( n ); | |
| 30 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] | |
| 31 | gap> NearRingRightIdeals( n ); | |
| 32 | [ < nearring right ideal >, < nearring right ideal >, | |
| 33 | < nearring right ideal > ] | |
| 34 | gap> NearRingLeftIdeals( n ); | |
| 35 | [ < nearring left ideal >, < nearring left ideal >, < nearring left ideal >, | |
| 36 | < nearring left ideal > ] | |
| 37 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 38 | LibraryNearRing(6/2, 39) | |
| 39 | gap> e := Enumerator(n)[3]; | |
| 40 | ((1,3,2)) | |
| 41 | gap> l := NearRingLeftIdealByGenerators( n, [e] ); | |
| 42 | < nearring left ideal > | |
| 43 | gap> IsNRI( l ); | |
| 44 | true | |
| 45 | gap> IsNearRingLeftIdeal( l ); | |
| 46 | true | |
| 47 | gap> IsNearRingRightIdeal( l ); | |
| 48 | true | |
| 49 | gap> l; | |
| 50 | < nearring ideal > | |
| 51 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 52 | LibraryNearRing(6/2, 39) | |
| 53 | gap> s := Subgroups( GroupReduct( n ) ); | |
| 54 | [ Group(()), Group([ (2,3) ]), Group([ (1,3) ]), Group([ (1,2) ]), | |
| 55 | Group([ (1,3,2) ]), Group([ (1,2,3), (1,2) ]) ] | |
| 56 | gap> List( s, sg -> IsSubgroupNearRingLeftIdeal( n, sg ) ); | |
| 57 | [ true, false, false, false, true, true ] | |
| 58 | gap> List( s, sg -> IsSubgroupNearRingRightIdeal( n, sg ) ); | |
| 59 | [ true, false, false, false, true, true ] | |
| 60 | gap> n := LibraryNearRingWithOne( GTW27_2, 5 ); | |
| 61 | LibraryNearRingWithOne(27/2, 5) | |
| 62 | gap> Filtered( NearRingIdeals( n ), IsPrimeNearRingIdeal ); | |
| 63 | [ < nearring ideal of size 9 >, < nearring ideal of size 27 > ] | |
| 64 | gap> n := LibraryNearRingWithOne( GTW27_2, 5 ); | |
| 65 | LibraryNearRingWithOne(27/2, 5) | |
| 66 | gap> Filtered( NearRingIdeals( n ), IsMaximalNearRingIdeal ); | |
| 67 | [ < nearring ideal of size 9 > ] | |
| 68 | gap> n := LibraryNearRing( GTW8_2, 2 ); | |
| 69 | LibraryNearRing(8/2, 2) | |
| 70 | gap> li := NearRingLeftIdeals( n ); | |
| 71 | [ < nearring left ideal >, < nearring left ideal >, | |
| 72 | < nearring left ideal >, < nearring left ideal >, | |
| 73 | < nearring left ideal >, < nearring left ideal > ] | |
| 74 | gap> l := li[3]; | |
| 75 | < nearring left ideal > | |
| 76 | gap> e := Enumerator( l );; | |
| 77 | gap> e[2]; | |
| 78 | ((1,2)(3,6,5,4)) | |
| 79 | gap> AsList( e ); AsList( l ); | |
| 80 | [ (()), ((1,2)(3,6,5,4)), ((3,5)(4,6)), ((1,2)(3,4,5,6)) ] | |
| 81 | [ (()), ((1,2)(3,6,5,4)), ((3,5)(4,6)), ((1,2)(3,4,5,6)) ] | |
| 82 | gap> Random( l ); | |
| 83 | ((3,5)(4,6)) | |
| 84 | gap> Random( n ) in l; | |
| 85 | true | |
| 86 | gap> Random( n ) in l; | |
| 87 | false | |
| 88 | gap> l := LibraryNearRing( GTW6_2, 3 ); | |
| 89 | LibraryNearRing(6/2, 3) | |
| 90 | gap> i := NearRingIdeals( l ); | |
| 91 | [ < nearring ideal >, < nearring ideal > ] | |
| 92 | gap> List( i, Size ); | |
| 93 | [ 1, 6 ] | |
| 94 | gap> NearRingCommutator( i[2], i[2] ); | |
| 95 | < nearring ideal of size 6 > | |
| 96 | gap> l := LibraryNearRing( GTW8_4, 13 ); | |
| 97 | LibraryNearRing(8/4, 13) | |
| 98 | gap> NearRingIdeals( l ); | |
| 99 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] | |
| 100 | gap> PrintNearRingCommutatorsTable( l ); | |
| 101 | [ 1, 1, 1 ] | |
| 102 | [ 1, 1, 2 ] | |
| 103 | [ 1, 2, 2 ] | |
| 104 | gap> NumberLibraryNearRings( GTW4_2 ); | |
| 105 | 23 | |
| 106 | gap> Filtered( AllLibraryNearRings( GTW4_2 ), IsSimpleNearRing ); | |
| 107 | [ LibraryNearRing(4/2, 3), LibraryNearRing(4/2, 16), | |
| 108 | LibraryNearRing(4/2, 17) ] | |
| 109 | gap> n := LibraryNearRing( GTW8_2, 2 ); | |
| 110 | LibraryNearRing(8/2, 2) | |
| 111 | gap> e := AsNearRingElement( n, (1,2) ); | |
| 112 | ((1,2)) | |
| 113 | gap> e in n; | |
| 114 | true | |
| 115 | gap> i := NearRingRightIdealByGenerators( n, [e] ); | |
| 116 | < nearring right ideal > | |
| 117 | gap> Size(i); | |
| 118 | 4 | |
| 119 | gap> IsNearRingLeftIdeal( i ); | |
| 120 | true | |
| 121 | gap> i; | |
| 122 | < nearring ideal of size 4 > | |
| 123 | gap> f := n/i; | |
| 124 | FactorNearRing( LibraryNearRing(8/2, 2), < nearring ideal of size 4 > ) | |
| 125 | gap> IdLibraryNearRing(f); | |
| 126 | [ 2/1, 1 ] |
| 0 | gap> G := GTW4_2; | |
| 1 | 4/2 | |
| 2 | gap> n := MapNearRing( G ); | |
| 3 | TransformationNearRing(4/2) | |
| 4 | gap> action := function ( g, f ) | |
| 5 | > return Image( f, g ); | |
| 6 | > end; | |
| 7 | function ( g, f ) ... end | |
| 8 | gap> gamma := NGroup( G, n, action ); | |
| 9 | < N-group of TransformationNearRing(4/2) > | |
| 10 | gap> IsNGroup( gamma ); | |
| 11 | true | |
| 12 | gap> NearRingActingOnNGroup( gamma ); | |
| 13 | TransformationNearRing(4/2) | |
| 14 | gap> ActionOfNearRingOnNGroup( gamma ); | |
| 15 | function ( g, f ) ... end | |
| 16 | gap> Print( ActionOfNearRingOnNGroup( gamma ) ); | |
| 17 | function ( g, f ) | |
| 18 | return Image( f, g ); | |
| 19 | gap> n := LibraryNearRing( GTW8_2, 3 ); | |
| 20 | LibraryNearRing(8/2, 3) | |
| 21 | gap> NGroupByNearRingMultiplication( n ) = GTW8_2; | |
| 22 | true | |
| 23 | gap> N := LibraryNearRing( GTW4_2, 11 ); | |
| 24 | LibraryNearRing(4/2, 11) | |
| 25 | gap> R := NearRingRightIdeals( N )[ 3 ]; | |
| 26 | < nearring right ideal > | |
| 27 | gap> ng := NGroupByRightIdealFactor( N, R ); | |
| 28 | < N-group of LibraryNearRing(4/2, 11) > | |
| 29 | gap> PrintTable( ng ); | |
| 30 | Let: | |
| 31 | (0,0) := (()) | |
| 32 | (1,0) := ((3,4)) | |
| 33 | (0,1) := ((1,2)) | |
| 34 | (1,1) := ((1,2)(3,4)) | |
| 35 | -------------------------------------------------------------------- | |
| 36 | g0 := <identity> of ... | |
| 37 | g1 := f1 | |
| 38 | ||
| 39 | N = LibraryNearRing(4/2, 11) acts on | |
| 40 | G = Group( [ f1 ] ) | |
| 41 | from the right by the following action: | |
| 42 | ||
| 43 | \ g0 g1 | |
| 44 | --------------- | |
| 45 | (0,0) \ g0 g0 | |
| 46 | (1,0) \ g0 g0 | |
| 47 | (0,1) \ g0 g1 | |
| 48 | (1,1) \ g0 g1 | |
| 49 | ||
| 50 | gap> n := LibraryNearRing( TWGroup( 8, 2 ), 3 ); | |
| 51 | LibraryNearRing(8/2, 3) | |
| 52 | gap> gamma := NGroupByNearRingMultiplication( n ); | |
| 53 | < N-group of LibraryNearRing(8/2, 3) > | |
| 54 | gap> PrintTable( gamma ); | |
| 55 | Let: | |
| 56 | n0 := (()) | |
| 57 | n1 := ((3,4,5,6)) | |
| 58 | n2 := ((3,5)(4,6)) | |
| 59 | n3 := ((3,6,5,4)) | |
| 60 | n4 := ((1,2)) | |
| 61 | n5 := ((1,2)(3,4,5,6)) | |
| 62 | n6 := ((1,2)(3,5)(4,6)) | |
| 63 | n7 := ((1,2)(3,6,5,4)) | |
| 64 | -------------------------------------------------------------------- | |
| 65 | g0 := () | |
| 66 | g1 := (3,4,5,6) | |
| 67 | g2 := (3,5)(4,6) | |
| 68 | g3 := (3,6,5,4) | |
| 69 | g4 := (1,2) | |
| 70 | g5 := (1,2)(3,4,5,6) | |
| 71 | g6 := (1,2)(3,5)(4,6) | |
| 72 | g7 := (1,2)(3,6,5,4) | |
| 73 | ||
| 74 | N = LibraryNearRing(8/2, 3) acts on | |
| 75 | G = Group( [ (1,2), (3,4,5,6) ] ) | |
| 76 | from the right by the following action: | |
| 77 | ||
| 78 | \ g0 g1 g2 g3 g4 g5 g6 g7 | |
| 79 | ------------------------------------ | |
| 80 | n0 \ g0 g0 g0 g0 g0 g0 g0 g0 | |
| 81 | n1 \ g0 g0 g0 g0 g0 g0 g0 g2 | |
| 82 | n2 \ g0 g0 g0 g0 g0 g0 g0 g0 | |
| 83 | n3 \ g0 g0 g0 g0 g0 g0 g0 g2 | |
| 84 | n4 \ g0 g0 g0 g0 g0 g0 g0 g0 | |
| 85 | n5 \ g0 g0 g0 g0 g0 g0 g0 g2 | |
| 86 | n6 \ g0 g0 g0 g0 g0 g0 g0 g0 | |
| 87 | n7 \ g0 g0 g0 g0 g0 g0 g0 g2 | |
| 88 | ||
| 89 | gap> n := LibraryNearRing( TWGroup( 8, 2 ), 3 ); | |
| 90 | LibraryNearRing(8/2, 3) | |
| 91 | gap> gamma := NGroupByNearRingMultiplication( n ); | |
| 92 | < N-group of LibraryNearRing(8/2, 3) > | |
| 93 | gap> NearRingActingOnNGroup( gamma ); | |
| 94 | LibraryNearRing(8/2, 3) | |
| 95 | gap> n := LibraryNearRing( TWGroup( 8, 2 ), 3 ); | |
| 96 | LibraryNearRing(8/2, 3) | |
| 97 | gap> gamma := NGroupByNearRingMultiplication( n ); | |
| 98 | < N-group of LibraryNearRing(8/2, 3) > | |
| 99 | gap> ActionOfNearRingOnNGroup( gamma ); | |
| 100 | function ( g, n ) ... end | |
| 101 | gap> n := LibraryNearRing(GTW12_3,20465); | |
| 102 | LibraryNearRing(12/3, 20465) | |
| 103 | gap> ng := NGroupByNearRingMultiplication( n ); | |
| 104 | < N-group of LibraryNearRing(12/3, 20465) > | |
| 105 | gap> Length( N0Subgroups( ng ) ); | |
| 106 | 9 | |
| 107 | gap> n:=LibraryNearRing(GTW12_3,20465); | |
| 108 | LibraryNearRing(12/3, 20465) | |
| 109 | gap> ng := NGroupByNearRingMultiplication( n ); | |
| 110 | < N-group of LibraryNearRing(12/3, 20465) > | |
| 111 | gap> NIdeals( ng ); | |
| 112 | [ < N-group of LibraryNearRing(12/3, 20465) >, | |
| 113 | < N-group of LibraryNearRing(12/3, 20465) >, | |
| 114 | < N-group of LibraryNearRing(12/3, 20465) > ] | |
| 115 | gap> n:=LibraryNearRing(GTW12_3,20465); | |
| 116 | LibraryNearRing(12/3, 20465) | |
| 117 | gap> ng := NGroupByNearRingMultiplication( n ); | |
| 118 | < N-group of LibraryNearRing(12/3, 20465) > | |
| 119 | gap> TypeOfNGroup( ng ); | |
| 120 | fail | |
| 121 | gap> N := LibraryNearRing( GTW12_3, 100 ); | |
| 122 | LibraryNearRing(12/3, 100) | |
| 123 | gap> I := NearRingIdeals( N ); | |
| 124 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] | |
| 125 | gap> List(I,Size); | |
| 126 | [ 1, 6, 12 ] | |
| 127 | gap> NN := NGroupByNearRingMultiplication( N ); | |
| 128 | < N-group of LibraryNearRing(12/3, 100) > | |
| 129 | gap> NoetherianQuotient( N, NN, GroupReduct(I[2]), GroupReduct(I[2]) ); | |
| 130 | < nearring ideal > | |
| 131 | gap> Size(last); | |
| 132 | 12 | |
| 133 | gap> f := LibraryNearRing( GTW8_4, 3 ); | |
| 134 | LibraryNearRing(8/4, 3) | |
| 135 | gap> NuRadicals( f ); | |
| 136 | rec( J2 := < nearring ideal >, J1 := < nearring ideal >, | |
| 137 | J1_2 := < nearring right ideal >, J0 := < nearring ideal > ) | |
| 138 | gap> NuRadical( f, 1/2 ); | |
| 139 | < nearring right ideal > | |
| 140 | gap> Size( NuRadical( f, 0 ) ); | |
| 141 | 8 | |
| 142 | gap> AsList( NuRadical( f, 1 ) ); | |
| 143 | [ (()), ((2,4)), ((1,2)(3,4)), ((1,2,3,4)), ((1,3)), ((1,3)(2,4)), | |
| 144 | ((1,4,3,2)), ((1,4)(2,3)) ] | |
| 145 | gap> NuRadical( f, 1/2 ) = NuRadical( f, 2 ); | |
| 146 | true |
| 0 | gap> C9 := CyclicGroup( 9 ); | |
| 1 | <pc group of size 9 with 2 generators> | |
| 2 | gap> a := GroupHomomorphismByFunction( C9, C9, x -> x^-1 );; | |
| 3 | gap> phi := Group( a );; | |
| 4 | gap> Size( phi ); | |
| 5 | 2 | |
| 6 | gap> IsFpfAutomorphismGroup( phi, C9 ); | |
| 7 | true | |
| 8 | gap> G := ElementaryAbelianGroup( 49 );; | |
| 9 | gap> FpfAutomorphismGroupsMaxSize( G ); | |
| 10 | [ 48, 2 ] | |
| 11 | gap> C15 := CyclicGroup( 15 );; | |
| 12 | gap> FpfAutomorphismGroupsMaxSize( C15 ); | |
| 13 | [ 2, 1 ] | |
| 14 | gap> aux := FpfAutomorphismGroupsMetacyclic( [3,3,5,5], 4, -1 ); | |
| 15 | [ [ [ [ f1, f2, f3, f4 ] -> [ f1^2, f2^3, f3*f4, f3*f4^2 ], | |
| 16 | [ f1, f2, f3, f4 ] -> [ f2^4, f1, f4^2, f3 ] ] ], | |
| 17 | <pc group of size 225 with 4 generators> ] | |
| 18 | gap> phi := Group( aux[1][1] ); | |
| 19 | <group with 2 generators> | |
| 20 | gap> G := aux[2]; | |
| 21 | <pc group of size 225 with 4 generators> | |
| 22 | gap> FrobeniusGroup( phi, G ); | |
| 23 | <pc group of size 1800 with 7 generators> | |
| 24 | gap> F := GF(5);; | |
| 25 | gap> A := [[2,0],[0,3]]*One(F); | |
| 26 | [ [ Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^3 ] ] | |
| 27 | gap> IsFpfRepresentation( [A], F ); | |
| 28 | true | |
| 29 | gap> DegreeOfIrredFpfRepCyclic( 5, 9 ); | |
| 30 | 6 | |
| 31 | gap> DegreeOfIrredFpfRepMetacyclic( 5, 4, -1 ); | |
| 32 | 2 | |
| 33 | gap> DegreeOfIrredFpfRep2( 7, 30, 11, -1 ); | |
| 34 | 8 | |
| 35 | gap> DegreeOfIrredFpfRep3( 5, 3, 1 ); | |
| 36 | 2 | |
| 37 | gap> DegreeOfIrredFpfRep4( 5, 3, 1, -1 ); | |
| 38 | 4 | |
| 39 | gap> aux := FpfRepresentationsCyclic( 5, 8 ); | |
| 40 | [ [ [ [ Z(5)^3, Z(5)^2 ], [ Z(5), Z(5) ] ], | |
| 41 | [ [ Z(5)^2, Z(5) ], [ Z(5)^0, Z(5)^0 ] ] ], [ 1, 7 ] ] | |
| 42 | gap> mats := aux[1]; | |
| 43 | [ [ [ Z(5)^3, Z(5)^2 ], [ Z(5), Z(5) ] ], | |
| 44 | [ [ Z(5)^2, Z(5) ], [ Z(5)^0, Z(5)^0 ] ] ] | |
| 45 | gap> indexlist := aux[2]; | |
| 46 | [ 1, 7 ] | |
| 47 | gap> aux := FpfRepresentationsMetacyclic( 7, 4, -1 ); | |
| 48 | [ [ [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 49 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ] ] ], [ 1 ] ] | |
| 50 | gap> mats := aux[1]; | |
| 51 | [ [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 52 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ] ] ] | |
| 53 | gap> DegreeOfIrredFpfRep2( 11, 30, 11, -1 ); | |
| 54 | 4 | |
| 55 | gap> aux := FpfRepresentations2( 11, 30, 11, -1 ); | |
| 56 | [ [ [ <block matrix of dimensions (2*2)x(2*2)>, | |
| 57 | <block matrix of dimensions (2*2)x(2*2)>, | |
| 58 | <block matrix of dimensions (2*2)x(2*2)> ], | |
| 59 | [ <block matrix of dimensions (2*2)x(2*2)>, | |
| 60 | <block matrix of dimensions (2*2)x(2*2)>, | |
| 61 | <block matrix of dimensions (2*2)x(2*2)> ] ], [ 1, 13 ] ] | |
| 62 | gap> aux := FpfRepresentations3( 5, 3, 1 ); | |
| 63 | [ [ [ [ [ Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^3 ] ], | |
| 64 | [ [ 0*Z(5), Z(5)^2 ], [ Z(5)^0, 0*Z(5) ] ], | |
| 65 | [ [ Z(5)^3, Z(5)^0 ], [ Z(5), Z(5)^0 ] ] ] ], [ 1 ] ] | |
| 66 | gap> aux := FpfRepresentations4( 7, 3, 1, -1 ); | |
| 67 | [ [ [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 68 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ], | |
| 69 | [ [ Z(7)^2, 0*Z(7) ], [ Z(7)^0, Z(7)^4 ] ], | |
| 70 | [ [ Z(7)^5, Z(7) ], [ Z(7), Z(7)^2 ] ] ], | |
| 71 | [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 72 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ], | |
| 73 | [ [ Z(7)^2, 0*Z(7) ], [ Z(7)^0, Z(7)^4 ] ], | |
| 74 | [ [ Z(7)^2, Z(7)^4 ], [ Z(7)^4, Z(7)^5 ] ] ] ], | |
| 75 | [ [ 1, 1 ], [ -1, 1 ] ] ] | |
| 76 | gap> aux := FpfAutomorphismGroupsCyclic( [25,5], 4 ); | |
| 77 | [ [ [ f1, f3 ] -> [ f1^2*f2, f3^2 ], | |
| 78 | [ f1, f3 ] -> [ f1^2*f2, f3^3 ] ], | |
| 79 | <pc group of size 125 with 2 generators> ] | |
| 80 | gap> as := aux[1]; | |
| 81 | [ [ f1, f3 ] -> [ f1^2*f2, f3^2 ], [ f1, f3 ] -> [ f1^2*f2, f3^3 ] ] | |
| 82 | gap> G := aux[2]; | |
| 83 | <pc group of size 125 with 2 generators> | |
| 84 | gap> aux := FpfAutomorphismGroupsMetacyclic( [3,3,5,5], 4, -1 ); | |
| 85 | [ [ [ [ f1, f2, f3, f4 ] -> [ f1^2, f2^3, f3*f4, f3*f4^2 ], | |
| 86 | [ f1, f2, f3, f4 ] -> [ f2^4, f1, f4^2, f3 ] ] ], | |
| 87 | <pc group of size 225 with 4 generators> ] | |
| 88 | gap> fs := aux[1]; | |
| 89 | [ [ [ f1, f2, f3, f4 ] -> [ f1^2, f2^3, f3*f4, f3*f4^2 ], | |
| 90 | [ f1, f2, f3, f4 ] -> [ f2^4, f1, f4^2, f3 ] ] ] | |
| 91 | gap> phi := Group( fs[1] ); | |
| 92 | <group with 2 generators> | |
| 93 | gap> G := aux[2]; | |
| 94 | <pc group of size 225 with 4 generators> | |
| 95 | gap> aux := FpfAutomorphismGroupsMetacyclic( [7,7,17,17], 8, -1 );; | |
| 96 | gap> fs := aux[1]; | |
| 97 | [ [ [ f1, f2, f3, f4 ] -> [ f1^9, f2^2, f3^4*f4^2, f3*f4^6 ], | |
| 98 | [ f1, f2, f3, f4 ] -> [ f2^16, f1, f3^4*f4^5, f3^5*f4^3 ] ], | |
| 99 | [ [ f1, f2, f3, f4 ] -> [ f1^9, f2^2, f3^3*f4^5, f3^6*f4 ], | |
| 100 | [ f1, f2, f3, f4 ] -> [ f2^16, f1, f3^3*f4^4, f3*f4^4 ] ] ] | |
| 101 | gap> phis := List( fs, Group ); | |
| 102 | [ <group with 2 generators>, <group with 2 generators> ] | |
| 103 | gap> G := aux[2]; | |
| 104 | <pc group of size 14161 with 4 generators> | |
| 105 | gap> aux := FpfAutomorphismGroups2( [11,11,11,11], 30, 11, -1 ); | |
| 106 | [ [ [ [ f1, f2, f3, f4 ] -> [ f1^5*f2^4, f1^3*f2^10, f3^2*f4^8, | |
| 107 | f3^6*f4 ], | |
| 108 | [ f1, f2, f3, f4 ] -> [ f1^3*f2^10, f1^10*f2^8, f3^8*f4, | |
| 109 | f3*f4^3 ], | |
| 110 | [ f1, f2, f3, f4 ] -> [ f3^10, f4^10, f1, f2 ] ] ], | |
| 111 | <pc group of size 14641 with 4 generators> ] | |
| 112 | gap> phi := Group( aux[1][1] ); | |
| 113 | <group with 3 generators> | |
| 114 | gap> G := aux[2]; | |
| 115 | <pc group of size 14641 with 4 generators> | |
| 116 | gap> aux := FpfAutomorphismGroups3( [5,5], 3, 1 ); | |
| 117 | [ [ [ [ f1, f2 ] -> [ f1^2, f2^3 ], [ f1, f2 ] -> [ f2^4, f1 ], | |
| 118 | [ f1, f2 ] -> [ f1^3*f2, f1^2*f2 ] ] ], | |
| 119 | <pc group of size 25 with 2 generators> ] | |
| 120 | gap> phi := Group( aux[1][1] ); | |
| 121 | <group with 3 generators> | |
| 122 | gap> G := aux[2]; | |
| 123 | <pc group of size 25 with 2 generators> | |
| 124 | gap> aux := FpfAutomorphismGroups4( [7,7], 3, 1, -1 ); | |
| 125 | [ [ [ [ f1, f2 ] -> [ f1^2*f2^3, f1^3*f2^5 ], | |
| 126 | [ f1, f2 ] -> [ f2^6, f1 ], [ f1, f2 ] -> [ f1^2, f1*f2^4 ], | |
| 127 | [ f1, f2 ] -> [ f1^5*f2^3, f1^3*f2^2 ] ] ], | |
| 128 | <pc group of size 49 with 2 generators> ] | |
| 129 | gap> phi := Group( aux[1][1] ); | |
| 130 | <group with 4 generators> | |
| 131 | gap> G := aux[2]; | |
| 132 | <pc group of size 49 with 2 generators> |
| 0 | \indexentry {Predefined groups@Predefined groups|indexit}{9} | |
| 1 | \indexentry {TWGroup@`TWGroup'}{9} | |
| 2 | \indexentry {IdTWGroup@`IdTWGroup'}{9} | |
| 3 | \indexentry {Operation tables for groups@Operation tables for groups|indexit}{10} | |
| 4 | \indexentry {PrintTable@`PrintTable'}{10} | |
| 5 | \indexentry {Group endomorphisms@Group endomorphisms|indexit}{10} | |
| 6 | \indexentry {Endomorphisms@`Endomorphisms'}{10} | |
| 7 | \indexentry {Group automorphisms@Group automorphisms|indexit}{11} | |
| 8 | \indexentry {Automorphisms@`Automorphisms'}{11} | |
| 9 | \indexentry {Inner automorphisms of a group@Inner automorphisms of a group|indexit}{11} | |
| 10 | \indexentry {InnerAutomorphisms@`InnerAutomorphisms'}{11} | |
| 11 | \indexentry {Isomorphic groups@Isomorphic groups|indexit}{11} | |
| 12 | \indexentry {IsIsomorphicGroup@`IsIsomorphicGroup'}{11} | |
| 13 | \indexentry {Subgroups of a group@Subgroups of a group|indexit}{12} | |
| 14 | \indexentry {Subgroups@`Subgroups'}{12} | |
| 15 | \indexentry {Normal subgroups generated by a single element@Normal subgroups generated by a single element|indexit}{12} | |
| 16 | \indexentry {OneGeneratedNormalSubgroups@`OneGeneratedNormalSubgroups'}{12} | |
| 17 | \indexentry {Invariant subgroups@Invariant subgroups|indexit}{12} | |
| 18 | \indexentry {IsInvariantUnderMaps@`IsInvariantUnderMaps'}{12} | |
| 19 | \indexentry {IsCharacteristicSubgroup@`IsCharacteristicSubgroup'}{12} | |
| 20 | \indexentry {IsCharacteristicInParent@`IsCharacteristicInParent'}{12} | |
| 21 | \indexentry {IsFullinvariant@`IsFullinvariant'}{13} | |
| 22 | \indexentry {IsFullinvariantInParent@`IsFullinvariantInParent'}{13} | |
| 23 | \indexentry {Coset representatives@Coset representatives|indexit}{13} | |
| 24 | \indexentry {RepresentativesModNormalSubgroup@`RepresentativesModNormalSubgroup'}{13} | |
| 25 | \indexentry {NontrivialRepresentativesModNormalSubgroup@`NontrivialRepresentativesModNormalSubgroup'}{13} | |
| 26 | \indexentry {Scott length@Scott length|indexit}{14} | |
| 27 | \indexentry {ScottLength@`ScottLength'}{14} | |
| 28 | \indexentry {Other useful functions for groups@Other useful functions for groups|indexit}{14} | |
| 29 | \indexentry {AsPermGroup@`AsPermGroup'}{14} | |
| 30 | \indexentry {Defining a nearring multiplication@Defining a nearring multiplication|indexit}{15} | |
| 31 | \indexentry {IsNearRingMultiplication@`IsNearRingMultiplication'}{15} | |
| 32 | \indexentry {NearRingMultiplicationByOperationTable@`NearRingMultiplicationByOperationTable'}{15} | |
| 33 | \indexentry {Construction of nearrings@Construction of nearrings|indexit}{16} | |
| 34 | \indexentry {ExplicitMultiplicationNearRing@`ExplicitMultiplicationNearRing'}{16} | |
| 35 | \indexentry {ExplicitMultiplicationNearRingNC@`ExplicitMultiplicationNearRingNC'}{16} | |
| 36 | \indexentry {IsNearRing@`IsNearRing'}{16} | |
| 37 | \indexentry {IsExplicitMultiplicationNearRing@`IsExplicitMultiplicationNearRing'}{16} | |
| 38 | \indexentry {Direct products of nearrings@Direct products of nearrings|indexit}{17} | |
| 39 | \indexentry {DirectProductNearRing@`DirectProductNearRing'}{17} | |
| 40 | \indexentry {Operation tables for nearrings@Operation tables for nearrings|indexit}{17} | |
| 41 | \indexentry {PrintTable@`PrintTable'!near rings}{17} | |
| 42 | \indexentry {Modified symbols for the operation tables@Modified symbols for the operation tables|indexit}{18} | |
| 43 | \indexentry {SetSymbols@`SetSymbols'}{18} | |
| 44 | \indexentry {SetSymbolsSupervised@`SetSymbolsSupervised'}{18} | |
| 45 | \indexentry {Symbols@`Symbols'}{18} | |
| 46 | \indexentry {Accessing nearring elements@Accessing nearring elements|indexit}{18} | |
| 47 | \indexentry {AsNearRingElement@`AsNearRingElement'}{18} | |
| 48 | \indexentry {AsGroupReductElement@`AsGroupReductElement'}{18} | |
| 49 | \indexentry {Nearring elements@Nearring elements|indexit}{19} | |
| 50 | \indexentry {AsList@`AsList'!near rings}{19} | |
| 51 | \indexentry {AsSortedList@`AsSortedList'!near rings}{19} | |
| 52 | \indexentry {Enumerator@`Enumerator'!near rings}{19} | |
| 53 | \indexentry {Random nearring elements@Random nearring elements|indexit}{20} | |
| 54 | \indexentry {Random@`Random'!near ring element}{20} | |
| 55 | \indexentry {Nearring generators@Nearring generators|indexit}{20} | |
| 56 | \indexentry {GeneratorsOfNearRing@`GeneratorsOfNearRing'}{20} | |
| 57 | \indexentry {Size of a nearring@Size of a nearring|indexit}{20} | |
| 58 | \indexentry {Size@`Size'!near rings}{20} | |
| 59 | \indexentry {The additive group of a nearring@The additive group of a nearring|indexit}{20} | |
| 60 | \indexentry {GroupReduct@`GroupReduct'}{20} | |
| 61 | \indexentry {Nearring endomorphisms@Nearring endomorphisms|indexit}{20} | |
| 62 | \indexentry {Endomorphisms@`Endomorphisms'!near rings}{20} | |
| 63 | \indexentry {Nearring automorphisms@Nearring automorphisms|indexit}{21} | |
| 64 | \indexentry {Automorphisms@`Automorphisms'!near rings}{21} | |
| 65 | \indexentry {Isomorphic nearrings@Isomorphic nearrings|indexit}{21} | |
| 66 | \indexentry {IsIsomorphicNearRing@`IsIsomorphicNearRing'}{21} | |
| 67 | \indexentry {Subnearrings@Subnearrings|indexit}{21} | |
| 68 | \indexentry {SubNearRings@`SubNearRings'}{21} | |
| 69 | \indexentry {Invariant subnearrings@Invariant subnearrings|indexit}{21} | |
| 70 | \indexentry {InvariantSubNearRings@`InvariantSubNearRings'}{21} | |
| 71 | \indexentry {Constructing subnearrings@Constructing subnearrings|indexit}{22} | |
| 72 | \indexentry {SubNearRingBySubgroupNC@`SubNearRingBySubgroupNC'}{22} | |
| 73 | \indexentry {Intersection of nearrings@Intersection of nearrings|indexit}{22} | |
| 74 | \indexentry {Intersection@`Intersection'!for nearrings}{22} | |
| 75 | \indexentry {Identity of a nearring@Identity of a nearring|indexit}{23} | |
| 76 | \indexentry {Identity@`Identity'}{23} | |
| 77 | \indexentry {One@`One'}{23} | |
| 78 | \indexentry {IsNearRingWithOne@`IsNearRingWithOne'}{23} | |
| 79 | \indexentry {Units of a nearring@Units of a nearring|indexit}{23} | |
| 80 | \indexentry {IsNearRingUnit@`IsNearRingUnit'}{23} | |
| 81 | \indexentry {NearRingUnits@`NearRingUnits'}{23} | |
| 82 | \indexentry {Distributivity in a nearring@Distributivity in a nearring|indexit}{24} | |
| 83 | \indexentry {Distributors@`Distributors'}{24} | |
| 84 | \indexentry {DistributiveElements@`DistributiveElements'}{24} | |
| 85 | \indexentry {IsDistributiveNearRing@`IsDistributiveNearRing'}{24} | |
| 86 | \indexentry {Elements of a nearring with special properties@Elements of a nearring with special properties|indexit}{24} | |
| 87 | \indexentry {ZeroSymmetricElements@`ZeroSymmetricElements'}{24} | |
| 88 | \indexentry {IdempotentElements@`IdempotentElements'}{25} | |
| 89 | \indexentry {NilpotentElements@`NilpotentElements'}{25} | |
| 90 | \indexentry {QuasiregularElements@`QuasiregularElements'}{25} | |
| 91 | \indexentry {RegularElements@`RegularElements'}{25} | |
| 92 | \indexentry {Special properties of a nearring@Special properties of a nearring|indexit}{26} | |
| 93 | \indexentry {IsAbelianNearRing@`IsAbelianNearRing'}{26} | |
| 94 | \indexentry {IsAbstractAffineNearRing@`IsAbstractAffineNearRing'}{26} | |
| 95 | \indexentry {IsBooleanNearRing@`IsBooleanNearRing'}{26} | |
| 96 | \indexentry {IsNilNearRing@`IsNilNearRing'}{26} | |
| 97 | \indexentry {IsNilpotentNearRing@`IsNilpotentNearRing'}{26} | |
| 98 | \indexentry {IsNilpotentFreeNearRing@`IsNilpotentFreeNearRing'}{27} | |
| 99 | \indexentry {IsCommutative@`IsCommutative'}{27} | |
| 100 | \indexentry {IsDgNearRing@`IsDgNearRing'}{27} | |
| 101 | \indexentry {IsIntegralNearRing@`IsIntegralNearRing'}{27} | |
| 102 | \indexentry {IsPrimeNearRing@`IsPrimeNearRing'}{27} | |
| 103 | \indexentry {IsQuasiregularNearRing@`IsQuasiregularNearRing'}{27} | |
| 104 | \indexentry {IsRegularNearRing@`IsRegularNearRing'}{28} | |
| 105 | \indexentry {IsNearField@`IsNearField'}{28} | |
| 106 | \indexentry {IsPlanarNearRing@`IsPlanarNearRing'}{28} | |
| 107 | \indexentry {IsWdNearRing@`IsWdNearRing'}{28} | |
| 108 | \indexentry {Extracting nearrings from the library@Extracting nearrings from the library|indexit}{29} | |
| 109 | \indexentry {LibraryNearRing@`LibraryNearRing'}{29} | |
| 110 | \indexentry {NumberLibraryNearRings@`NumberLibraryNearRings'}{29} | |
| 111 | \indexentry {AllLibraryNearRings@`AllLibraryNearRings'}{29} | |
| 112 | \indexentry {LibraryNearRingWithOne@`LibraryNearRingWithOne'}{29} | |
| 113 | \indexentry {NumberLibraryNearRingsWithOne@`NumberLibraryNearRingsWithOne'}{29} | |
| 114 | \indexentry {AllLibraryNearRingsWithOne@`AllLibraryNearRingsWithOne'}{29} | |
| 115 | \indexentry {Identifying nearrings@Identifying nearrings|indexit}{30} | |
| 116 | \indexentry {IdLibraryNearRing@`IdLibraryNearRing'}{30} | |
| 117 | \indexentry {IdLibraryNearRingWithOne@`IdLibraryNearRingWithOne'}{30} | |
| 118 | \indexentry {IsLibraryNearRing@IsLibraryNearRing|indexit}{30} | |
| 119 | \indexentry {IsLibraryNearRing@`IsLibraryNearRing'}{30} | |
| 120 | \indexentry {Accessing the information about a nearring stored in the library@Accessing the information about a nearring stored in the library|indexit}{31} | |
| 121 | \indexentry {LibraryNearRingInfo@`LibraryNearRingInfo'}{31} | |
| 122 | \indexentry {Defining endo mappings@Defining endo mappings|indexit}{32} | |
| 123 | \indexentry {EndoMappingByPositionList @`EndoMappingByPositionList '}{32} | |
| 124 | \indexentry {EndoMappingByFunction@`EndoMappingByFunction'}{32} | |
| 125 | \indexentry {AsEndoMapping@`AsEndoMapping'}{32} | |
| 126 | \indexentry {AsGroupGeneralMappingByImages@`AsGroupGeneralMappingByImages'}{33} | |
| 127 | \indexentry {IsEndoMapping@`IsEndoMapping'}{33} | |
| 128 | \indexentry {IdentityEndoMapping@`IdentityEndoMapping'}{33} | |
| 129 | \indexentry {ConstantEndoMapping@`ConstantEndoMapping'}{33} | |
| 130 | \indexentry {Properties of endo mappings@Properties of endo mappings|indexit}{34} | |
| 131 | \indexentry {IsIdentityEndoMapping@`IsIdentityEndoMapping'}{34} | |
| 132 | \indexentry {IsConstantEndoMapping@`IsConstantEndoMapping'}{34} | |
| 133 | \indexentry {IsDistributiveEndoMapping@`IsDistributiveEndoMapping'}{34} | |
| 134 | \indexentry {Operations for endo mappings@Operations for endo mappings|indexit}{34} | |
| 135 | \indexentry {Nicer ways to print a mapping@Nicer ways to print a mapping|indexit}{35} | |
| 136 | \indexentry {GraphOfMapping@`GraphOfMapping'}{35} | |
| 137 | \indexentry {PrintAsTerm@`PrintAsTerm'}{35} | |
| 138 | \indexentry {Constructing transformation nearrings@Constructing transformation nearrings|indexit}{37} | |
| 139 | \indexentry {TransformationNearRingByGenerators@`TransformationNearRingByGenerators'}{37} | |
| 140 | \indexentry {TransformationNearRingByAdditiveGenerators@`TransformationNearRingByAdditiveGenerators'}{37} | |
| 141 | \indexentry {Nearrings of transformations@Nearrings of transformations|indexit}{38} | |
| 142 | \indexentry {MapNearRing@`MapNearRing'}{38} | |
| 143 | \indexentry {TransformationNearRing@`TransformationNearRing'}{38} | |
| 144 | \indexentry {IsFullTransformationNearRing@`IsFullTransformationNearRing'}{38} | |
| 145 | \indexentry {PolynomialNearRing@`PolynomialNearRing'}{38} | |
| 146 | \indexentry {EndomorphismNearRing@`EndomorphismNearRing'}{38} | |
| 147 | \indexentry {AutomorphismNearRing@`AutomorphismNearRing'}{39} | |
| 148 | \indexentry {InnerAutomorphismNearRing@`InnerAutomorphismNearRing'}{39} | |
| 149 | \indexentry {CompatibleFunctionNearRing@`CompatibleFunctionNearRing'}{39} | |
| 150 | \indexentry {ZeroSymmetricCompatibleFunctionNearRing@`ZeroSymmetricCompatibleFunctionNearRing'}{39} | |
| 151 | \indexentry {IsCompatibleEndoMapping@`IsCompatibleEndoMapping'}{39} | |
| 152 | \indexentry {Is1AffineComplete@`Is1AffineComplete'}{39} | |
| 153 | \indexentry {CentralizerNearRing@`CentralizerNearRing'}{39} | |
| 154 | \indexentry {RestrictedEndomorphismNearRing@`RestrictedEndomorphismNearRing'}{40} | |
| 155 | \indexentry {LocalInterpolationNearRing@`LocalInterpolationNearRing'}{40} | |
| 156 | \indexentry {The group a transformation nearring acts on@The group a transformation nearring acts on|indexit}{41} | |
| 157 | \indexentry {Gamma@`Gamma'}{41} | |
| 158 | \indexentry {Transformation nearrings and other nearrings@Transformation nearrings and other nearrings|indexit}{41} | |
| 159 | \indexentry {AsTransformationNearRing@`AsTransformationNearRing'}{41} | |
| 160 | \indexentry {AsExplicitMultiplicationNearRing@`AsExplicitMultiplicationNearRing'}{41} | |
| 161 | \indexentry {Noetherian quotients for transformation nearrings@Noetherian quotients for transformation nearrings|indexit}{41} | |
| 162 | \indexentry {NoetherianQuotient@`NoetherianQuotient'!for transformation nearrings}{41} | |
| 163 | \indexentry {CongruenceNoetherianQuotient@`CongruenceNoetherianQuotient'!for nearrings of polynomial functions}{42} | |
| 164 | \indexentry {CongruenceNoetherianQuotientForInnerAutomorphismNearRings @`CongruenceNoetherianQuotientForInnerAutomorphismNearRings '!for inner automorphism nearrings}{42} | |
| 165 | \indexentry {Zerosymmetric mappings@Zerosymmetric mappings|indexit}{42} | |
| 166 | \indexentry {ZeroSymmetricPart@`ZeroSymmetricPart'!for transformation nearrings}{42} | |
| 167 | \indexentry {Construction of nearring ideals@Construction of nearring ideals|indexit}{44} | |
| 168 | \indexentry {NearRingIdealByGenerators@`NearRingIdealByGenerators'}{44} | |
| 169 | \indexentry {NearRingLeftIdealByGenerators@`NearRingLeftIdealByGenerators'}{44} | |
| 170 | \indexentry {NearRingRightIdealByGenerators@`NearRingRightIdealByGenerators'}{44} | |
| 171 | \indexentry {NearRingIdealBySubgroupNC@`NearRingIdealBySubgroupNC'}{45} | |
| 172 | \indexentry {NearRingLeftIdealBySubgroupNC@`NearRingLeftIdealBySubgroupNC'}{45} | |
| 173 | \indexentry {NearRingRightIdealBySubgroupNC@`NearRingRightIdealBySubgroupNC'}{45} | |
| 174 | \indexentry {NearRingIdeals@`NearRingIdeals'}{45} | |
| 175 | \indexentry {NearRingLeftIdeals@`NearRingLeftIdeals'}{45} | |
| 176 | \indexentry {NearRingRightIdeals@`NearRingRightIdeals'}{45} | |
| 177 | \indexentry {Testing for ideal properties@Testing for ideal properties|indexit}{46} | |
| 178 | \indexentry {IsNRI@`IsNRI'}{46} | |
| 179 | \indexentry {IsNearRingLeftIdeal@`IsNearRingLeftIdeal'}{46} | |
| 180 | \indexentry {IsNearRingRightIdeal@`IsNearRingRightIdeal'}{46} | |
| 181 | \indexentry {IsNearRingIdeal@`IsNearRingIdeal'}{46} | |
| 182 | \indexentry {IsSubgroupNearRingLeftIdeal@`IsSubgroupNearRingLeftIdeal'}{46} | |
| 183 | \indexentry {IsSubgroupNearRingRightIdeal@`IsSubgroupNearRingRightIdeal'}{47} | |
| 184 | \indexentry {Special ideal properties@Special ideal properties|indexit}{47} | |
| 185 | \indexentry {IsPrimeNearRingIdeal@`IsPrimeNearRingIdeal'}{47} | |
| 186 | \indexentry {IsMaximalNearRingIdeal@`IsMaximalNearRingIdeal'}{47} | |
| 187 | \indexentry {Generators of nearring ideals@Generators of nearring ideals|indexit}{47} | |
| 188 | \indexentry {GeneratorsOfNearRingIdeal@`GeneratorsOfNearRingIdeal'}{47} | |
| 189 | \indexentry {GeneratorsOfNearRingLeftIdeal@`GeneratorsOfNearRingLeftIdeal'}{47} | |
| 190 | \indexentry {GeneratorsOfNearRingRightIdeal@`GeneratorsOfNearRingRightIdeal'}{47} | |
| 191 | \indexentry {Near-ring ideal elements@Near-ring ideal elements|indexit}{48} | |
| 192 | \indexentry {AsList@`AsList'!near ring ideals}{48} | |
| 193 | \indexentry {AsSortedList@`AsSortedList'!near ring ideals}{48} | |
| 194 | \indexentry {Enumerator@`Enumerator'!near ring ideals}{48} | |
| 195 | \indexentry {Random ideal elements@Random ideal elements|indexit}{48} | |
| 196 | \indexentry {Random@`Random'!near ring ideal element}{48} | |
| 197 | \indexentry {Membership of an ideal@Membership of an ideal|indexit}{48} | |
| 198 | \indexentry {in}{48} | |
| 199 | \indexentry {Size of ideals@Size of ideals|indexit}{48} | |
| 200 | \indexentry {Size@`Size'!near ring ideals}{48} | |
| 201 | \indexentry {Group reducts of ideals@Group reducts of ideals|indexit}{49} | |
| 202 | \indexentry {GroupReduct@`GroupReduct'!near ring ideals}{49} | |
| 203 | \indexentry {Comparision of ideals@Comparision of ideals|indexit}{49} | |
| 204 | \indexentry {=}{49} | |
| 205 | \indexentry {Operations with ideals@Operations with ideals|indexit}{49} | |
| 206 | \indexentry {Intersection@`Intersection'!for nearring ideals}{49} | |
| 207 | \indexentry {Intersection@`Intersection'}{49} | |
| 208 | \indexentry {ClosureNearRingLeftIdeal@`ClosureNearRingLeftIdeal'}{49} | |
| 209 | \indexentry {ClosureNearRingRightIdeal@`ClosureNearRingRightIdeal'}{49} | |
| 210 | \indexentry {ClosureNearRingIdeal@`ClosureNearRingIdeal'}{49} | |
| 211 | \indexentry {Commutators@Commutators|indexit}{49} | |
| 212 | \indexentry {NearRingCommutator@`NearRingCommutator'}{49} | |
| 213 | \indexentry {Simple nearrings@Simple nearrings|indexit}{50} | |
| 214 | \indexentry {IsSimpleNearRing@`IsSimpleNearRing'}{50} | |
| 215 | \indexentry {Factor nearrings@Factor nearrings|indexit}{50} | |
| 216 | \indexentry {FactorNearRing@`FactorNearRing'}{50} | |
| 217 | \indexentry {/}{50} | |
| 218 | \indexentry {GraphicIdealLattice@`GraphicIdealLattice'}{51} | |
| 219 | \indexentry {Construction of N-groups@Construction of N-groups|indexit}{52} | |
| 220 | \indexentry {NGroup@`NGroup'}{52} | |
| 221 | \indexentry {NGroupByNearRingMultiplication@`NGroupByNearRingMultiplication'}{52} | |
| 222 | \indexentry {NGroupByApplication@`NGroupByApplication'}{53} | |
| 223 | \indexentry {NGroupByRightIdealFactor@`NGroupByRightIdealFactor'}{53} | |
| 224 | \indexentry {Operation tables of N-groups@Operation tables of N-groups|indexit}{53} | |
| 225 | \indexentry {PrintTable@`PrintTable'!for N-groups}{53} | |
| 226 | \indexentry {Functions for N-groups@Functions for N-groups|indexit}{54} | |
| 227 | \indexentry {IsNGroup@`IsNGroup'}{54} | |
| 228 | \indexentry {NearRingActingOnNGroup@`NearRingActingOnNGroup'}{54} | |
| 229 | \indexentry {ActionOfNearRingOnNGroup@`ActionOfNearRingOnNGroup'}{55} | |
| 230 | \indexentry {N-subgroups@N-subgroups|indexit}{55} | |
| 231 | \indexentry {NSubgroup@`NSubgroup'}{55} | |
| 232 | \indexentry {NSubgroups@`NSubgroups'}{55} | |
| 233 | \indexentry {IsNSubgroup@`IsNSubgroup'}{55} | |
| 234 | \indexentry {N0-subgroups@N0-subgroups|indexit}{55} | |
| 235 | \indexentry {N0Subgroups@`N0Subgroups'}{55} | |
| 236 | \indexentry {Ideals of N-groups@Ideals of N-groups|indexit}{55} | |
| 237 | \indexentry {NIdeal@`NIdeal'}{55} | |
| 238 | \indexentry {NIdeals@`NIdeals'}{55} | |
| 239 | \indexentry {IsNIdeal@`IsNIdeal'}{56} | |
| 240 | \indexentry {IsSimpleNGroup@`IsSimpleNGroup'}{56} | |
| 241 | \indexentry {IsN0SimpleNGroup@`IsN0SimpleNGroup'}{56} | |
| 242 | \indexentry {Special properties of N-groups@Special properties of N-groups|indexit}{56} | |
| 243 | \indexentry {IsCompatible@`IsCompatible'}{56} | |
| 244 | \indexentry {IsTameNGroup@`IsTameNGroup'}{56} | |
| 245 | \indexentry {Is2TameNGroup@`Is2TameNGroup'}{56} | |
| 246 | \indexentry {Is3TameNGroup@`Is3TameNGroup'}{56} | |
| 247 | \indexentry {IsMonogenic@`IsMonogenic'}{56} | |
| 248 | \indexentry {IsStronglyMonogenic@`IsStronglyMonogenic'}{56} | |
| 249 | \indexentry {TypeOfNGroup@`TypeOfNGroup'}{56} | |
| 250 | \indexentry {Noetherian quotients@Noetherian quotients|indexit}{57} | |
| 251 | \indexentry {NoetherianQuotient@`NoetherianQuotient'}{57} | |
| 252 | \indexentry {Nearring radicals@Nearring radicals|indexit}{57} | |
| 253 | \indexentry {NuRadical@`NuRadical'}{57} | |
| 254 | \indexentry {NuRadicals@`NuRadicals'}{57} | |
| 255 | \indexentry {Fixed-point-free automorphism groups and Frobenius groups@Fixed-point-free automorphism groups and Frobenius groups|indexit}{58} | |
| 256 | \indexentry {IsFpfAutomorphismGroup@`IsFpfAutomorphismGroup'}{58} | |
| 257 | \indexentry {FpfAutomorphismGroupsMaxSize@`FpfAutomorphismGroupsMaxSize'}{58} | |
| 258 | \indexentry {FrobeniusGroup@`FrobeniusGroup'}{59} | |
| 259 | \indexentry {Fixed-point-free representations@Fixed-point-free representations|indexit}{59} | |
| 260 | \indexentry {IsFpfRepresentation@`IsFpfRepresentation'}{59} | |
| 261 | \indexentry {DegreeOfIrredFpfRepCyclic@`DegreeOfIrredFpfRepCyclic'}{59} | |
| 262 | \indexentry {DegreeOfIrredFpfRepMetacyclic@`DegreeOfIrredFpfRepMetacyclic'}{59} | |
| 263 | \indexentry {DegreeOfIrredFpfRep2@`DegreeOfIrredFpfRep2'}{60} | |
| 264 | \indexentry {DegreeOfIrredFpfRep3@`DegreeOfIrredFpfRep3'}{60} | |
| 265 | \indexentry {DegreeOfIrredFpfRep4@`DegreeOfIrredFpfRep4'}{60} | |
| 266 | \indexentry {FpfRepresentationsCyclic@`FpfRepresentationsCyclic'}{60} | |
| 267 | \indexentry {FpfRepresentationsMetacyclic@`FpfRepresentationsMetacyclic'}{61} | |
| 268 | \indexentry {FpfRepresentations2@`FpfRepresentations2'}{61} | |
| 269 | \indexentry {FpfRepresentations3@`FpfRepresentations3'}{62} | |
| 270 | \indexentry {FpfRepresentations4@`FpfRepresentations4'}{63} | |
| 271 | \indexentry {Fixed-point-free automorphism groups@Fixed-point-free automorphism groups|indexit}{64} | |
| 272 | \indexentry {FpfAutomorphismGroupsCyclic@`FpfAutomorphismGroupsCyclic'}{64} | |
| 273 | \indexentry {FpfAutomorphismGroupsMetacyclic@`FpfAutomorphismGroupsMetacyclic'}{64} | |
| 274 | \indexentry {FpfAutomorphismGroups2@`FpfAutomorphismGroups2'}{65} | |
| 275 | \indexentry {FpfAutomorphismGroups3@`FpfAutomorphismGroups3'}{65} | |
| 276 | \indexentry {FpfAutomorphismGroups4@`FpfAutomorphismGroups4'}{66} | |
| 277 | \indexentry {Dickson numbers@Dickson numbers|indexit}{67} | |
| 278 | \indexentry {IsPairOfDicksonNumbers@`IsPairOfDicksonNumbers'}{67} | |
| 279 | \indexentry {Dickson nearfields@Dickson nearfields|indexit}{67} | |
| 280 | \indexentry {DicksonNearFields@`DicksonNearFields'}{67} | |
| 281 | \indexentry {NumberOfDicksonNearFields@`NumberOfDicksonNearFields'}{68} | |
| 282 | \indexentry {Exceptional nearfields@Exceptional nearfields|indexit}{68} | |
| 283 | \indexentry {ExceptionalNearFields@`ExceptionalNearFields'}{68} | |
| 284 | \indexentry {AllExceptionalNearFields@`AllExceptionalNearFields'}{68} | |
| 285 | \indexentry {Planar nearrings@Planar nearrings|indexit}{69} | |
| 286 | \indexentry {PlanarNearRing@`PlanarNearRing'}{69} | |
| 287 | \indexentry {OrbitRepresentativesForPlanarNearRing@`OrbitRepresentativesForPlanarNearRing'}{69} | |
| 288 | \indexentry {Weakly divisible nearrings@Weakly divisible nearrings|indexit}{70} | |
| 289 | \indexentry {WdNearRing@`WdNearRing'}{70} | |
| 290 | \indexentry {Constructing a design@Constructing a design|indexit}{71} | |
| 291 | \indexentry {DesignFromPointsAndBlocks@`DesignFromPointsAndBlocks'}{71} | |
| 292 | \indexentry {DesignFromIncidenceMat@`DesignFromIncidenceMat'}{71} | |
| 293 | \indexentry {DesignFromPlanarNearRing@`DesignFromPlanarNearRing'}{71} | |
| 294 | \indexentry {DesignFromFerreroPair@`DesignFromFerreroPair'}{72} | |
| 295 | \indexentry {DesignFromWdNearRing@`DesignFromWdNearRing'}{72} | |
| 296 | \indexentry {Properties of a design@Properties of a design|indexit}{73} | |
| 297 | \indexentry {PointsOfDesign@`PointsOfDesign'}{73} | |
| 298 | \indexentry {BlocksOfDesign@`BlocksOfDesign'}{73} | |
| 299 | \indexentry {DesignParameter@`DesignParameter'}{73} | |
| 300 | \indexentry {IncidenceMat@`IncidenceMat'}{73} | |
| 301 | \indexentry {PrintIncidenceMat@`PrintIncidenceMat'}{74} | |
| 302 | \indexentry {BlockIntersectionNumbers@`BlockIntersectionNumbers'}{74} | |
| 303 | \indexentry {BlockIntersectionNumbersK@`BlockIntersectionNumbersK'}{74} | |
| 304 | \indexentry {IsCircularDesign@`IsCircularDesign'}{74} | |
| 305 | \indexentry {Working with the points and blocks of a design@Working with the points and blocks of a design|indexit}{74} | |
| 306 | \indexentry {IsPointIncidentBlock@`IsPointIncidentBlock'}{74} | |
| 307 | \indexentry {PointsIncidentBlocks@`PointsIncidentBlocks'}{75} | |
| 308 | \indexentry {BlocksIncidentPoints@`BlocksIncidentPoints'}{75} |
| 0 | \makelabel{sonata:Copyright notice}{{\setbox 0=\hbox {1}\vrule width 0pt height\ht 0}} | |
| 1 | \makelabel{sonata:The authors}{{\setbox 0=\hbox {1}\vrule width 0pt height\ht 0}} | |
| 2 | \makelabel{sonata:Preface}{{\setbox 0=\hbox {1}\vrule width 0pt height\ht 0}} | |
| 3 | \makelabel{sonata:Supportive functions for groups}{1} | |
| 4 | \makelabel{sonata:Predefined groups}{1.1} | |
| 5 | \makelabel{sonata:TWGroup}{1.1.1} | |
| 6 | \makelabel{sonata:IdTWGroup}{1.1.2} | |
| 7 | \makelabel{sonata:Operation tables for groups}{1.2} | |
| 8 | \makelabel{sonata:PrintTable}{1.2.1} | |
| 9 | \makelabel{sonata:Group endomorphisms}{1.3} | |
| 10 | \makelabel{sonata:Endomorphisms}{1.3.1} | |
| 11 | \makelabel{sonata:Group automorphisms}{1.4} | |
| 12 | \makelabel{sonata:Automorphisms}{1.4.1} | |
| 13 | \makelabel{sonata:Inner automorphisms of a group}{1.5} | |
| 14 | \makelabel{sonata:InnerAutomorphisms}{1.5.1} | |
| 15 | \makelabel{sonata:Isomorphic groups}{1.6} | |
| 16 | \makelabel{sonata:IsIsomorphicGroup}{1.6.1} | |
| 17 | \makelabel{sonata:Subgroups of a group}{1.7} | |
| 18 | \makelabel{sonata:Subgroups}{1.7.1} | |
| 19 | \makelabel{sonata:Normal subgroups generated by a single element}{1.8} | |
| 20 | \makelabel{sonata:OneGeneratedNormalSubgroups}{1.8.1} | |
| 21 | \makelabel{sonata:Invariant subgroups}{1.9} | |
| 22 | \makelabel{sonata:IsInvariantUnderMaps}{1.9.1} | |
| 23 | \makelabel{sonata:IsCharacteristicSubgroup}{1.9.2} | |
| 24 | \makelabel{sonata:IsCharacteristicInParent}{1.9.3} | |
| 25 | \makelabel{sonata:IsFullinvariant}{1.9.4} | |
| 26 | \makelabel{sonata:IsFullinvariantInParent}{1.9.5} | |
| 27 | \makelabel{sonata:Coset representatives}{1.10} | |
| 28 | \makelabel{sonata:RepresentativesModNormalSubgroup}{1.10.1} | |
| 29 | \makelabel{sonata:NontrivialRepresentativesModNormalSubgroup}{1.10.2} | |
| 30 | \makelabel{sonata:Scott length}{1.11} | |
| 31 | \makelabel{sonata:ScottLength}{1.11.1} | |
| 32 | \makelabel{sonata:Other useful functions for groups}{1.12} | |
| 33 | \makelabel{sonata:AsPermGroup}{1.12.1} | |
| 34 | \makelabel{sonata:Nearrings}{2} | |
| 35 | \makelabel{sonata:Defining a nearring multiplication}{2.1} | |
| 36 | \makelabel{sonata:IsNearRingMultiplication}{2.1.1} | |
| 37 | \makelabel{sonata:NearRingMultiplicationByOperationTable}{2.1.2} | |
| 38 | \makelabel{sonata:Construction of nearrings}{2.2} | |
| 39 | \makelabel{sonata:ExplicitMultiplicationNearRing}{2.2.1} | |
| 40 | \makelabel{sonata:ExplicitMultiplicationNearRingNC}{2.2.2} | |
| 41 | \makelabel{sonata:IsNearRing}{2.2.3} | |
| 42 | \makelabel{sonata:IsExplicitMultiplicationNearRing}{2.2.4} | |
| 43 | \makelabel{sonata:Direct products of nearrings}{2.3} | |
| 44 | \makelabel{sonata:DirectProductNearRing}{2.3.1} | |
| 45 | \makelabel{sonata:Operation tables for nearrings}{2.4} | |
| 46 | \makelabel{sonata:PrintTable!near rings}{2.4.1} | |
| 47 | \makelabel{sonata:Modified symbols for the operation tables}{2.5} | |
| 48 | \makelabel{sonata:SetSymbols}{2.5.1} | |
| 49 | \makelabel{sonata:SetSymbolsSupervised}{2.5.1} | |
| 50 | \makelabel{sonata:Symbols}{2.5.2} | |
| 51 | \makelabel{sonata:Accessing nearring elements}{2.6} | |
| 52 | \makelabel{sonata:AsNearRingElement}{2.6.1} | |
| 53 | \makelabel{sonata:AsGroupReductElement}{2.6.2} | |
| 54 | \makelabel{sonata:Nearring elements}{2.7} | |
| 55 | \makelabel{sonata:AsList!near rings}{2.7.1} | |
| 56 | \makelabel{sonata:AsSortedList!near rings}{2.7.2} | |
| 57 | \makelabel{sonata:Enumerator!near rings}{2.7.3} | |
| 58 | \makelabel{sonata:Random nearring elements}{2.8} | |
| 59 | \makelabel{sonata:Random!near ring element}{2.8.1} | |
| 60 | \makelabel{sonata:Nearring generators}{2.9} | |
| 61 | \makelabel{sonata:GeneratorsOfNearRing}{2.9.1} | |
| 62 | \makelabel{sonata:Size of a nearring}{2.10} | |
| 63 | \makelabel{sonata:Size!near rings}{2.10.1} | |
| 64 | \makelabel{sonata:The additive group of a nearring}{2.11} | |
| 65 | \makelabel{sonata:GroupReduct}{2.11.1} | |
| 66 | \makelabel{sonata:Nearring endomorphisms}{2.12} | |
| 67 | \makelabel{sonata:Endomorphisms!near rings}{2.12.1} | |
| 68 | \makelabel{sonata:Nearring automorphisms}{2.13} | |
| 69 | \makelabel{sonata:Automorphisms!near rings}{2.13.1} | |
| 70 | \makelabel{sonata:Isomorphic nearrings}{2.14} | |
| 71 | \makelabel{sonata:IsIsomorphicNearRing}{2.14.1} | |
| 72 | \makelabel{sonata:Subnearrings}{2.15} | |
| 73 | \makelabel{sonata:SubNearRings}{2.15.1} | |
| 74 | \makelabel{sonata:Invariant subnearrings}{2.16} | |
| 75 | \makelabel{sonata:InvariantSubNearRings}{2.16.1} | |
| 76 | \makelabel{sonata:Constructing subnearrings}{2.17} | |
| 77 | \makelabel{sonata:SubNearRingBySubgroupNC}{2.17.1} | |
| 78 | \makelabel{sonata:Intersection of nearrings}{2.18} | |
| 79 | \makelabel{sonata:Intersection!for nearrings}{2.18.1} | |
| 80 | \makelabel{sonata:Identity of a nearring}{2.19} | |
| 81 | \makelabel{sonata:Identity}{2.19.1} | |
| 82 | \makelabel{sonata:One}{2.19.2} | |
| 83 | \makelabel{sonata:IsNearRingWithOne}{2.19.3} | |
| 84 | \makelabel{sonata:Units of a nearring}{2.20} | |
| 85 | \makelabel{sonata:IsNearRingUnit}{2.20.1} | |
| 86 | \makelabel{sonata:NearRingUnits}{2.20.2} | |
| 87 | \makelabel{sonata:Distributivity in a nearring}{2.21} | |
| 88 | \makelabel{sonata:Distributors}{2.21.1} | |
| 89 | \makelabel{sonata:DistributiveElements}{2.21.2} | |
| 90 | \makelabel{sonata:IsDistributiveNearRing}{2.21.3} | |
| 91 | \makelabel{sonata:Elements of a nearring with special properties}{2.22} | |
| 92 | \makelabel{sonata:ZeroSymmetricElements}{2.22.1} | |
| 93 | \makelabel{sonata:IdempotentElements}{2.22.2} | |
| 94 | \makelabel{sonata:NilpotentElements}{2.22.3} | |
| 95 | \makelabel{sonata:QuasiregularElements}{2.22.4} | |
| 96 | \makelabel{sonata:RegularElements}{2.22.5} | |
| 97 | \makelabel{sonata:Special properties of a nearring}{2.23} | |
| 98 | \makelabel{sonata:IsAbelianNearRing}{2.23.1} | |
| 99 | \makelabel{sonata:IsAbstractAffineNearRing}{2.23.2} | |
| 100 | \makelabel{sonata:IsBooleanNearRing}{2.23.3} | |
| 101 | \makelabel{sonata:IsNilNearRing}{2.23.4} | |
| 102 | \makelabel{sonata:IsNilpotentNearRing}{2.23.5} | |
| 103 | \makelabel{sonata:IsNilpotentFreeNearRing}{2.23.6} | |
| 104 | \makelabel{sonata:IsCommutative}{2.23.7} | |
| 105 | \makelabel{sonata:IsDgNearRing}{2.23.8} | |
| 106 | \makelabel{sonata:IsIntegralNearRing}{2.23.9} | |
| 107 | \makelabel{sonata:IsPrimeNearRing}{2.23.10} | |
| 108 | \makelabel{sonata:IsQuasiregularNearRing}{2.23.11} | |
| 109 | \makelabel{sonata:IsRegularNearRing}{2.23.12} | |
| 110 | \makelabel{sonata:IsNearField}{2.23.13} | |
| 111 | \makelabel{sonata:IsPlanarNearRing}{2.23.14} | |
| 112 | \makelabel{sonata:IsWdNearRing}{2.23.15} | |
| 113 | \makelabel{sonata:The nearring library}{3} | |
| 114 | \makelabel{sonata:Extracting nearrings from the library}{3.1} | |
| 115 | \makelabel{sonata:LibraryNearRing}{3.1.1} | |
| 116 | \makelabel{sonata:NumberLibraryNearRings}{3.1.2} | |
| 117 | \makelabel{sonata:AllLibraryNearRings}{3.1.3} | |
| 118 | \makelabel{sonata:LibraryNearRingWithOne}{3.1.4} | |
| 119 | \makelabel{sonata:NumberLibraryNearRingsWithOne}{3.1.5} | |
| 120 | \makelabel{sonata:AllLibraryNearRingsWithOne}{3.1.6} | |
| 121 | \makelabel{sonata:Identifying nearrings}{3.2} | |
| 122 | \makelabel{sonata:IdLibraryNearRing}{3.2.1} | |
| 123 | \makelabel{sonata:IdLibraryNearRingWithOne}{3.2.2} | |
| 124 | \makelabel{sonata:IsLibraryNearRing}{3.3} | |
| 125 | \makelabel{sonata:IsLibraryNearRing}{3.3.1} | |
| 126 | \makelabel{sonata:Accessing the information about a nearring stored in the library}{3.4} | |
| 127 | \makelabel{sonata:LibraryNearRingInfo}{3.4.1} | |
| 128 | \makelabel{sonata:Arbitrary functions on groups: EndoMappings}{4} | |
| 129 | \makelabel{sonata:Defining endo mappings}{4.1} | |
| 130 | \makelabel{sonata:EndoMappingByPositionList }{4.1.1} | |
| 131 | \makelabel{sonata:EndoMappingByFunction}{4.1.2} | |
| 132 | \makelabel{sonata:AsEndoMapping}{4.1.3} | |
| 133 | \makelabel{sonata:AsGroupGeneralMappingByImages}{4.1.4} | |
| 134 | \makelabel{sonata:IsEndoMapping}{4.1.5} | |
| 135 | \makelabel{sonata:IdentityEndoMapping}{4.1.6} | |
| 136 | \makelabel{sonata:ConstantEndoMapping}{4.1.7} | |
| 137 | \makelabel{sonata:Properties of endo mappings}{4.2} | |
| 138 | \makelabel{sonata:IsIdentityEndoMapping}{4.2.1} | |
| 139 | \makelabel{sonata:IsConstantEndoMapping}{4.2.2} | |
| 140 | \makelabel{sonata:IsDistributiveEndoMapping}{4.2.3} | |
| 141 | \makelabel{sonata:Operations for endo mappings}{4.3} | |
| 142 | \makelabel{sonata:Nicer ways to print a mapping}{4.4} | |
| 143 | \makelabel{sonata:GraphOfMapping}{4.4.1} | |
| 144 | \makelabel{sonata:PrintAsTerm}{4.4.2} | |
| 145 | \makelabel{sonata:Transformation nearrings}{5} | |
| 146 | \makelabel{sonata:Constructing transformation nearrings}{5.1} | |
| 147 | \makelabel{sonata:TransformationNearRingByGenerators}{5.1.1} | |
| 148 | \makelabel{sonata:TransformationNearRingByAdditiveGenerators}{5.1.2} | |
| 149 | \makelabel{sonata:Nearrings of transformations}{5.2} | |
| 150 | \makelabel{sonata:MapNearRing}{5.2.1} | |
| 151 | \makelabel{sonata:TransformationNearRing}{5.2.2} | |
| 152 | \makelabel{sonata:IsFullTransformationNearRing}{5.2.3} | |
| 153 | \makelabel{sonata:PolynomialNearRing}{5.2.4} | |
| 154 | \makelabel{sonata:EndomorphismNearRing}{5.2.5} | |
| 155 | \makelabel{sonata:AutomorphismNearRing}{5.2.6} | |
| 156 | \makelabel{sonata:InnerAutomorphismNearRing}{5.2.7} | |
| 157 | \makelabel{sonata:CompatibleFunctionNearRing}{5.2.8} | |
| 158 | \makelabel{sonata:ZeroSymmetricCompatibleFunctionNearRing}{5.2.9} | |
| 159 | \makelabel{sonata:IsCompatibleEndoMapping}{5.2.10} | |
| 160 | \makelabel{sonata:Is1AffineComplete}{5.2.11} | |
| 161 | \makelabel{sonata:CentralizerNearRing}{5.2.12} | |
| 162 | \makelabel{sonata:RestrictedEndomorphismNearRing}{5.2.13} | |
| 163 | \makelabel{sonata:LocalInterpolationNearRing}{5.2.14} | |
| 164 | \makelabel{sonata:The group a transformation nearring acts on}{5.3} | |
| 165 | \makelabel{sonata:Gamma}{5.3.1} | |
| 166 | \makelabel{sonata:Transformation nearrings and other nearrings}{5.4} | |
| 167 | \makelabel{sonata:AsTransformationNearRing}{5.4.1} | |
| 168 | \makelabel{sonata:AsExplicitMultiplicationNearRing}{5.4.2} | |
| 169 | \makelabel{sonata:Noetherian quotients for transformation nearrings}{5.5} | |
| 170 | \makelabel{sonata:NoetherianQuotient!for transformation nearrings}{5.5.1} | |
| 171 | \makelabel{sonata:CongruenceNoetherianQuotient!for nearrings of polynomial functions}{5.5.2} | |
| 172 | \makelabel{sonata:CongruenceNoetherianQuotientForInnerAutomorphismNearRings !for inner automorphism nearrings}{5.5.3} | |
| 173 | \makelabel{sonata:Zerosymmetric mappings}{5.6} | |
| 174 | \makelabel{sonata:ZeroSymmetricPart!for transformation nearrings}{5.6.1} | |
| 175 | \makelabel{sonata:Nearring ideals}{6} | |
| 176 | \makelabel{sonata:Construction of nearring ideals}{6.1} | |
| 177 | \makelabel{sonata:NearRingIdealByGenerators}{6.1.1} | |
| 178 | \makelabel{sonata:NearRingLeftIdealByGenerators}{6.1.2} | |
| 179 | \makelabel{sonata:NearRingRightIdealByGenerators}{6.1.3} | |
| 180 | \makelabel{sonata:NearRingIdealBySubgroupNC}{6.1.4} | |
| 181 | \makelabel{sonata:NearRingLeftIdealBySubgroupNC}{6.1.5} | |
| 182 | \makelabel{sonata:NearRingRightIdealBySubgroupNC}{6.1.6} | |
| 183 | \makelabel{sonata:NearRingIdeals}{6.1.7} | |
| 184 | \makelabel{sonata:NearRingLeftIdeals}{6.1.8} | |
| 185 | \makelabel{sonata:NearRingRightIdeals}{6.1.9} | |
| 186 | \makelabel{sonata:Testing for ideal properties}{6.2} | |
| 187 | \makelabel{sonata:IsNRI}{6.2.1} | |
| 188 | \makelabel{sonata:IsNearRingLeftIdeal}{6.2.2} | |
| 189 | \makelabel{sonata:IsNearRingRightIdeal}{6.2.3} | |
| 190 | \makelabel{sonata:IsNearRingIdeal}{6.2.4} | |
| 191 | \makelabel{sonata:IsSubgroupNearRingLeftIdeal}{6.2.5} | |
| 192 | \makelabel{sonata:IsSubgroupNearRingRightIdeal}{6.2.6} | |
| 193 | \makelabel{sonata:Special ideal properties}{6.3} | |
| 194 | \makelabel{sonata:IsPrimeNearRingIdeal}{6.3.1} | |
| 195 | \makelabel{sonata:IsMaximalNearRingIdeal}{6.3.2} | |
| 196 | \makelabel{sonata:Generators of nearring ideals}{6.4} | |
| 197 | \makelabel{sonata:GeneratorsOfNearRingIdeal}{6.4.1} | |
| 198 | \makelabel{sonata:GeneratorsOfNearRingLeftIdeal}{6.4.2} | |
| 199 | \makelabel{sonata:GeneratorsOfNearRingRightIdeal}{6.4.3} | |
| 200 | \makelabel{sonata:Near-ring ideal elements}{6.5} | |
| 201 | \makelabel{sonata:AsList!near ring ideals}{6.5.1} | |
| 202 | \makelabel{sonata:AsSortedList!near ring ideals}{6.5.2} | |
| 203 | \makelabel{sonata:Enumerator!near ring ideals}{6.5.3} | |
| 204 | \makelabel{sonata:Random ideal elements}{6.6} | |
| 205 | \makelabel{sonata:Random!near ring ideal element}{6.6.1} | |
| 206 | \makelabel{sonata:Membership of an ideal}{6.7} | |
| 207 | \makelabel{sonata:in}{6.7.1} | |
| 208 | \makelabel{sonata:Size of ideals}{6.8} | |
| 209 | \makelabel{sonata:Size!near ring ideals}{6.8.1} | |
| 210 | \makelabel{sonata:Group reducts of ideals}{6.9} | |
| 211 | \makelabel{sonata:GroupReduct!near ring ideals}{6.9.1} | |
| 212 | \makelabel{sonata:Comparision of ideals}{6.10} | |
| 213 | \makelabel{sonata:=}{6.10.1} | |
| 214 | \makelabel{sonata:Operations with ideals}{6.11} | |
| 215 | \makelabel{sonata:Intersection!for nearring ideals}{6.11.1} | |
| 216 | \makelabel{sonata:Intersection}{6.11.2} | |
| 217 | \makelabel{sonata:ClosureNearRingLeftIdeal}{6.11.3} | |
| 218 | \makelabel{sonata:ClosureNearRingRightIdeal}{6.11.4} | |
| 219 | \makelabel{sonata:ClosureNearRingIdeal}{6.11.5} | |
| 220 | \makelabel{sonata:Commutators}{6.12} | |
| 221 | \makelabel{sonata:NearRingCommutator}{6.12.1} | |
| 222 | \makelabel{sonata:Simple nearrings}{6.13} | |
| 223 | \makelabel{sonata:IsSimpleNearRing}{6.13.1} | |
| 224 | \makelabel{sonata:Factor nearrings}{6.14} | |
| 225 | \makelabel{sonata:FactorNearRing}{6.14.1} | |
| 226 | \makelabel{sonata:/}{6.14.2} | |
| 227 | \makelabel{sonata:Graphic ideal lattices (X-GAP only)}{7} | |
| 228 | \makelabel{sonata:GraphicIdealLattice}{7} | |
| 229 | \makelabel{sonata:N-groups}{8} | |
| 230 | \makelabel{sonata:Construction of N-groups}{8.1} | |
| 231 | \makelabel{sonata:NGroup}{8.1.1} | |
| 232 | \makelabel{sonata:NGroupByNearRingMultiplication}{8.1.2} | |
| 233 | \makelabel{sonata:NGroupByApplication}{8.1.3} | |
| 234 | \makelabel{sonata:NGroupByRightIdealFactor}{8.1.4} | |
| 235 | \makelabel{sonata:Operation tables of N-groups}{8.2} | |
| 236 | \makelabel{sonata:PrintTable!for N-groups}{8.2.1} | |
| 237 | \makelabel{sonata:Functions for N-groups}{8.3} | |
| 238 | \makelabel{sonata:IsNGroup}{8.3.1} | |
| 239 | \makelabel{sonata:NearRingActingOnNGroup}{8.3.2} | |
| 240 | \makelabel{sonata:ActionOfNearRingOnNGroup}{8.3.3} | |
| 241 | \makelabel{sonata:N-subgroups}{8.4} | |
| 242 | \makelabel{sonata:NSubgroup}{8.4.1} | |
| 243 | \makelabel{sonata:NSubgroups}{8.4.2} | |
| 244 | \makelabel{sonata:IsNSubgroup}{8.4.3} | |
| 245 | \makelabel{sonata:N0-subgroups}{8.5} | |
| 246 | \makelabel{sonata:N0Subgroups}{8.5.1} | |
| 247 | \makelabel{sonata:Ideals of N-groups}{8.6} | |
| 248 | \makelabel{sonata:NIdeal}{8.6.1} | |
| 249 | \makelabel{sonata:NIdeals}{8.6.2} | |
| 250 | \makelabel{sonata:IsNIdeal}{8.6.3} | |
| 251 | \makelabel{sonata:IsSimpleNGroup}{8.6.4} | |
| 252 | \makelabel{sonata:IsN0SimpleNGroup}{8.6.5} | |
| 253 | \makelabel{sonata:Special properties of N-groups}{8.7} | |
| 254 | \makelabel{sonata:IsCompatible}{8.7.1} | |
| 255 | \makelabel{sonata:IsTameNGroup}{8.7.2} | |
| 256 | \makelabel{sonata:Is2TameNGroup}{8.7.3} | |
| 257 | \makelabel{sonata:Is3TameNGroup}{8.7.4} | |
| 258 | \makelabel{sonata:IsMonogenic}{8.7.5} | |
| 259 | \makelabel{sonata:IsStronglyMonogenic}{8.7.6} | |
| 260 | \makelabel{sonata:TypeOfNGroup}{8.7.7} | |
| 261 | \makelabel{sonata:Noetherian quotients}{8.8} | |
| 262 | \makelabel{sonata:NoetherianQuotient}{8.8.1} | |
| 263 | \makelabel{sonata:Nearring radicals}{8.9} | |
| 264 | \makelabel{sonata:NuRadical}{8.9.1} | |
| 265 | \makelabel{sonata:NuRadicals}{8.9.2} | |
| 266 | \makelabel{sonata:Fixed-point-free automorphism groups}{9} | |
| 267 | \makelabel{sonata:Fixed-point-free automorphism groups and Frobenius groups}{9.1} | |
| 268 | \makelabel{sonata:IsFpfAutomorphismGroup}{9.1.1} | |
| 269 | \makelabel{sonata:FpfAutomorphismGroupsMaxSize}{9.1.2} | |
| 270 | \makelabel{sonata:FrobeniusGroup}{9.1.3} | |
| 271 | \makelabel{sonata:Fixed-point-free representations}{9.2} | |
| 272 | \makelabel{sonata:IsFpfRepresentation}{9.2.1} | |
| 273 | \makelabel{sonata:DegreeOfIrredFpfRepCyclic}{9.2.2} | |
| 274 | \makelabel{sonata:DegreeOfIrredFpfRepMetacyclic}{9.2.3} | |
| 275 | \makelabel{sonata:DegreeOfIrredFpfRep2}{9.2.4} | |
| 276 | \makelabel{sonata:DegreeOfIrredFpfRep3}{9.2.5} | |
| 277 | \makelabel{sonata:DegreeOfIrredFpfRep4}{9.2.6} | |
| 278 | \makelabel{sonata:FpfRepresentationsCyclic}{9.2.7} | |
| 279 | \makelabel{sonata:FpfRepresentationsMetacyclic}{9.2.8} | |
| 280 | \makelabel{sonata:FpfRepresentations2}{9.2.9} | |
| 281 | \makelabel{sonata:FpfRepresentations3}{9.2.10} | |
| 282 | \makelabel{sonata:FpfRepresentations4}{9.2.11} | |
| 283 | \makelabel{sonata:Fixed-point-free automorphism groups}{9.3} | |
| 284 | \makelabel{sonata:FpfAutomorphismGroupsCyclic}{9.3.1} | |
| 285 | \makelabel{sonata:FpfAutomorphismGroupsMetacyclic}{9.3.2} | |
| 286 | \makelabel{sonata:FpfAutomorphismGroups2}{9.3.3} | |
| 287 | \makelabel{sonata:FpfAutomorphismGroups3}{9.3.4} | |
| 288 | \makelabel{sonata:FpfAutomorphismGroups4}{9.3.5} | |
| 289 | \makelabel{sonata:Nearfields, planar nearrings and weakly divisible nearrings}{10} | |
| 290 | \makelabel{sonata:Dickson numbers}{10.1} | |
| 291 | \makelabel{sonata:IsPairOfDicksonNumbers}{10.1.1} | |
| 292 | \makelabel{sonata:Dickson nearfields}{10.2} | |
| 293 | \makelabel{sonata:DicksonNearFields}{10.2.1} | |
| 294 | \makelabel{sonata:NumberOfDicksonNearFields}{10.2.2} | |
| 295 | \makelabel{sonata:Exceptional nearfields}{10.3} | |
| 296 | \makelabel{sonata:ExceptionalNearFields}{10.3.1} | |
| 297 | \makelabel{sonata:AllExceptionalNearFields}{10.3.2} | |
| 298 | \makelabel{sonata:Planar nearrings}{10.4} | |
| 299 | \makelabel{sonata:PlanarNearRing}{10.4.1} | |
| 300 | \makelabel{sonata:OrbitRepresentativesForPlanarNearRing}{10.4.2} | |
| 301 | \makelabel{sonata:Weakly divisible nearrings}{10.5} | |
| 302 | \makelabel{sonata:WdNearRing}{10.5.1} | |
| 303 | \makelabel{sonata:Designs}{11} | |
| 304 | \makelabel{sonata:Constructing a design}{11.1} | |
| 305 | \makelabel{sonata:DesignFromPointsAndBlocks}{11.1.1} | |
| 306 | \makelabel{sonata:DesignFromIncidenceMat}{11.1.2} | |
| 307 | \makelabel{sonata:DesignFromPlanarNearRing}{11.1.3} | |
| 308 | \makelabel{sonata:DesignFromFerreroPair}{11.1.4} | |
| 309 | \makelabel{sonata:DesignFromWdNearRing}{11.1.5} | |
| 310 | \makelabel{sonata:Properties of a design}{11.2} | |
| 311 | \makelabel{sonata:PointsOfDesign}{11.2.1} | |
| 312 | \makelabel{sonata:BlocksOfDesign}{11.2.2} | |
| 313 | \makelabel{sonata:DesignParameter}{11.2.3} | |
| 314 | \makelabel{sonata:IncidenceMat}{11.2.4} | |
| 315 | \makelabel{sonata:PrintIncidenceMat}{11.2.5} | |
| 316 | \makelabel{sonata:BlockIntersectionNumbers}{11.2.6} | |
| 317 | \makelabel{sonata:BlockIntersectionNumbersK}{11.2.6} | |
| 318 | \makelabel{sonata:IsCircularDesign}{11.2.7} | |
| 319 | \makelabel{sonata:Working with the points and blocks of a design}{11.3} | |
| 320 | \makelabel{sonata:IsPointIncidentBlock}{11.3.1} | |
| 321 | \makelabel{sonata:PointsIncidentBlocks}{11.3.2} | |
| 322 | \makelabel{sonata:BlocksIncidentPoints}{11.3.3} | |
| 323 | \makelabel{sonata:Bibliography}{} | |
| 324 | \makelabel{sonata:Index}{} |
| 0 | This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016) (preloaded format=pdftex 2017.5.16) 7 OCT 2018 20:24 | |
| 1 | entering extended mode | |
| 2 | restricted \write18 enabled. | |
| 3 | %&-line parsing enabled. | |
| 4 | **manual | |
| 5 | (./manual.tex (../gapmacro.tex | |
| 6 | (/usr/local/texlive/2016/texmf-dist/tex/plain/amsfonts/amssym.tex | |
| 7 | (/usr/local/texlive/2016/texmf-dist/tex/plain/amsfonts/amssym.def | |
| 8 | \msafam=\fam8 | |
| 9 | \msbfam=\fam9 | |
| 10 | \eufmfam=\fam10 | |
| 11 | )) | |
| 12 | Running PDFTeX | |
| 13 | \pagewidth=\dimen16 | |
| 14 | \pageheight=\dimen17 | |
| 15 | \colwidth=\dimen18 | |
| 16 | \partialpage=\box16 | |
| 17 | \origvsize=\dimen19 | |
| 18 | \manindent=\dimen20 | |
| 19 | \smallmanindent=\dimen21 | |
| 20 | \itfam=\fam11 | |
| 21 | \slfam=\fam12 | |
| 22 | \bffam=\fam13 | |
| 23 | \ttfam=\fam14 | |
| 24 | \msbfam=\fam15 | |
| 25 | \ttindent=\dimen22 | |
| 26 | \labelout=\write0 | |
| 27 | \indexout=\write1 | |
| 28 | \secindout=\write2 | |
| 29 | \tocout=\write3 | |
| 30 | \citeout=\write4 | |
| 31 | \ans=\write5 | |
| 32 | \exampleout=\write6 | |
| 33 | \labelin=\read1 | |
| 34 | \indexin=\read2 | |
| 35 | \tocin=\read3 | |
| 36 | \citein=\read4 | |
| 37 | \secno=\count27 | |
| 38 | \subsecno=\count28 | |
| 39 | \exno=\count29 | |
| 40 | \indentno=\count30 | |
| 41 | \chapnum=\count31 | |
| 42 | \ortoks=\toks13 | |
| 43 | \bibindent=\dimen23 | |
| 44 | ) [1{/usr/local/texlive/2016/texmf-var/fonts/map/pdftex/updmap/pdftex.map}] | |
| 45 | \makelabel{sonata:Contents}{{\setbox 0=\hbox {1}\vrule width 0pt height\ht 0}} | |
| 46 | Chapter `Contents' . | |
| 47 | (./manual.toc [2.1 | |
| 48 | \chapcontents {\tocstrut }{Contents}{2} | |
| 49 | ]) [3.1] (./manual.lab) | |
| 50 | \openout3 = `manual.toc'. | |
| 51 | ||
| 52 | \openout0 = `manual.lab'. | |
| 53 | ||
| 54 | \openout1 = `manual.idx'. | |
| 55 | ||
| 56 | \openout2 = `manual.six'. | |
| 57 | ||
| 58 | \openout4 = `manual.aux'. | |
| 59 | ||
| 60 | [4.1] (./copyrigh.tex | |
| 61 | Chapter `Copyright notice' . | |
| 62 | ) (./authors.tex [5.2] | |
| 63 | Chapter `The authors' . | |
| 64 | ) (./preface.tex [6.3] | |
| 65 | Chapter `Preface' . | |
| 66 | [7.4]) [8.4] (./grpsupp.tex | |
| 67 | Chapter `Supportive functions for groups' . | |
| 68 | Reference `thomaswood80:GT' undefined. | |
| 69 | \openout6 = `manual.example-1.tst'. | |
| 70 | ||
| 71 | [9.1] [10.1] [11.1] [12.1] | |
| 72 | Reference `scott69:TAOPMOAGATSOCPPGI' undefined. | |
| 73 | Reference `ecker98:OTNOPFONGOC2' undefined. | |
| 74 | [13.1]) (./nr.tex [14.1] | |
| 75 | Chapter `Nearrings' . | |
| 76 | Reference `Pilz:Nearrings' undefined. | |
| 77 | Reference `meldrum85:NATLWG' undefined. | |
| 78 | Reference `Clay:Nearrings' undefined. | |
| 79 | \openout6 = `manual.example-2.tst'. | |
| 80 | ||
| 81 | [15.2] [16.2] [17.2] [18.2] [19.2] [20.2] [21.2] [22.2] [23.2] [24.2] [25.2] | |
| 82 | [26.2] [27.2]) (./libnr.tex [28.2] | |
| 83 | Chapter `The nearring library' . | |
| 84 | \openout6 = `manual.example-3.tst'. | |
| 85 | ||
| 86 | [29.3] [30.3]) (./tfms.tex [31.3] | |
| 87 | Chapter `Arbitrary functions on groups: EndoMappings' . | |
| 88 | \openout6 = `manual.example-4.tst'. | |
| 89 | ||
| 90 | [32.4] [33.4] [34.4]) (./tfmnr.tex [35.4] [36.4] | |
| 91 | Chapter `Transformation nearrings' . | |
| 92 | Reference `Pilz:Nearrings' undefined. | |
| 93 | Reference `meldrum85:NATLWG' undefined. | |
| 94 | Reference `Clay:Nearrings' undefined. | |
| 95 | Reference `aichingereckernoebauer00:TUOCINT' undefined. | |
| 96 | Reference `aichingerea00:CWN' undefined. | |
| 97 | \openout6 = `manual.example-5.tst'. | |
| 98 | ||
| 99 | [37.5] [38.5] [39.5] [40.5] [41.5] [42.5]) (./ideals.tex [43.5] | |
| 100 | Chapter `Nearring ideals' . | |
| 101 | Reference `Pilz:Nearrings' undefined. | |
| 102 | Reference `meldrum85:NATLWG' undefined. | |
| 103 | Reference `Clay:Nearrings' undefined. | |
| 104 | ||
| 105 | Overfull \hbox (11.90366pt too wide) in paragraph at lines 5--7 | |
| 106 | []\tenr For an in-tro-duc-tion to near-ring ide-als we sug-gest [][][][Pilz:Nea | |
| 107 | rrings][][], [][][][mel-drum85:NATLWG][][], and [][][][Clay:Nearrings][][]. | | |
| 108 | ||
| 109 | \hbox(7.5+2.5)x468.0, glue set - 1.0 | |
| 110 | .\hbox(0.0+0.0)x0.0 | |
| 111 | .\tenr F | |
| 112 | .\kern-0.83334 | |
| 113 | .\tenr o | |
| 114 | .\tenr r | |
| 115 | .etc. | |
| 116 | ||
| 117 | \openout6 = `manual.example-6.tst'. | |
| 118 | ||
| 119 | [44.6] [45.6] [46.6] [47.6] [48.6] [49.6]) (./xsonata.tex [50.6] | |
| 120 | Chapter `Graphic ideal lattices (X-GAP only)' . | |
| 121 | ) (./ngroups.tex [51.7] | |
| 122 | Chapter `N-groups' . | |
| 123 | \openout6 = `manual.example-8.tst'. | |
| 124 | ||
| 125 | [52.8] [53.8] [54.8] [55.8] [56.8]) (./fpf.tex [57.8] | |
| 126 | Chapter `Fixed-point-free automorphism groups' . | |
| 127 | Reference `Wolf:Spaces' undefined. | |
| 128 | Reference `Mayr:Representations' undefined. | |
| 129 | \openout6 = `manual.example-9.tst'. | |
| 130 | ||
| 131 | [58.9] [59.9] [60.9] [61.9] [62.9] [63.9] [64.9] [65.9]) (./nfplwd.tex [66.9] | |
| 132 | Chapter `Nearfields, planar nearrings and weakly divisible nearrings' . | |
| 133 | Reference `Waehling:Fastkoerper' undefined. | |
| 134 | Reference `Clay:Nearrings' undefined. | |
| 135 | \openout6 = `manual.example-10.tst'. | |
| 136 | ||
| 137 | [67.10] | |
| 138 | Reference `Clay:Nearrings' undefined. | |
| 139 | [68.10] [69.10]) (./design.tex [70.10] | |
| 140 | Chapter `Designs' . | |
| 141 | \openout6 = `manual.example-11.tst'. | |
| 142 | ||
| 143 | Reference `Clay:Nearrings' undefined. | |
| 144 | [71.11] | |
| 145 | Reference `Clay:Nearrings' undefined. | |
| 146 | [72.11] [73.11] [74.11]) [75.11] | |
| 147 | Chapter `Bibliography' . | |
| 148 | No file manual.bbl. | |
| 149 | [76.12] | |
| 150 | Chapter `Index' . | |
| 151 | No file manual.ind. | |
| 152 | ## | |
| 153 | ## Citations for BibTeX written on manual.aux. | |
| 154 | ## Index entries for makeindex written on manual.idx. | |
| 155 | ## Section index entries written on manual.six. | |
| 156 | ## Label definitions written on manual.lab. | |
| 157 | ## Table of contents written on manual.toc. | |
| 158 | ## Examples written to manual.example-XX.tst. | |
| 159 | ## There were undefined labels or references. | |
| 160 | ## Labels have changed, run again. (Or they were multiply defined.) | |
| 161 | ## | |
| 162 | [77.13] )pdfTeX warning (dest): name{index} has been referenced but does not ex | |
| 163 | ist, replaced by a fixed one | |
| 164 | ||
| 165 | pdfTeX warning (dest): name{citation@Waehling:Fastkoerper} has been referenced | |
| 166 | but does not exist, replaced by a fixed one | |
| 167 | ||
| 168 | pdfTeX warning (dest): name{citation@Mayr:Representations} has been referenced | |
| 169 | but does not exist, replaced by a fixed one | |
| 170 | ||
| 171 | pdfTeX warning (dest): name{citation@Wolf:Spaces} has been referenced but does | |
| 172 | not exist, replaced by a fixed one | |
| 173 | ||
| 174 | pdfTeX warning (dest): name{citation@aichingerea00:CWN} has been referenced but | |
| 175 | does not exist, replaced by a fixed one | |
| 176 | ||
| 177 | pdfTeX warning (dest): name{citation@aichingereckernoebauer00:TUOCINT} has been | |
| 178 | referenced but does not exist, replaced by a fixed one | |
| 179 | ||
| 180 | pdfTeX warning (dest): name{citation@Clay:Nearrings} has been referenced but do | |
| 181 | es not exist, replaced by a fixed one | |
| 182 | ||
| 183 | pdfTeX warning (dest): name{citation@meldrum85:NATLWG} has been referenced but | |
| 184 | does not exist, replaced by a fixed one | |
| 185 | ||
| 186 | pdfTeX warning (dest): name{citation@Pilz:Nearrings} has been referenced but do | |
| 187 | es not exist, replaced by a fixed one | |
| 188 | ||
| 189 | pdfTeX warning (dest): name{citation@ecker98:OTNOPFONGOC2} has been referenced | |
| 190 | but does not exist, replaced by a fixed one | |
| 191 | ||
| 192 | pdfTeX warning (dest): name{citation@scott69:TAOPMOAGATSOCPPGI} has been refere | |
| 193 | nced but does not exist, replaced by a fixed one | |
| 194 | ||
| 195 | pdfTeX warning (dest): name{citation@thomaswood80:GT} has been referenced but d | |
| 196 | oes not exist, replaced by a fixed one | |
| 197 | ||
| 198 | </usr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmbx10.pfb>< | |
| 199 | /usr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cminch.pfb></ | |
| 200 | usr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi10.pfb></u | |
| 201 | sr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi7.pfb></usr | |
| 202 | /local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb></usr/l | |
| 203 | ocal/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmr7.pfb></usr/loca | |
| 204 | l/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmr8.pfb></usr/local/t | |
| 205 | exlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmss10.pfb></usr/local/te | |
| 206 | xlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmssdc10.pfb></usr/local/t | |
| 207 | exlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy10.pfb></usr/local/te | |
| 208 | xlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy5.pfb></usr/local/texl | |
| 209 | ive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy7.pfb></usr/local/texliv | |
| 210 | e/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmti10.pfb></usr/local/texlive | |
| 211 | /2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt10.pfb></usr/local/texlive/ | |
| 212 | 2016/texmf-dist/fonts/type1/public/amsfonts/symbols/msam7.pfb></usr/local/texli | |
| 213 | ve/2016/texmf-dist/fonts/type1/public/amsfonts/symbols/msbm10.pfb> | |
| 214 | Output written on manual.pdf (77 pages, 358528 bytes). | |
| 215 | PDF statistics: | |
| 216 | 1159 PDF objects out of 1200 (max. 8388607) | |
| 217 | 1053 compressed objects within 11 object streams | |
| 218 | 334 named destinations out of 1000 (max. 500000) | |
| 219 | 801 words of extra memory for PDF output out of 10000 (max. 10000000) | |
| 220 |
| 0 | preamble "" | |
| 1 | postamble "\n" | |
| 2 | group_skip "\n" | |
| 3 | headings_flag 1 | |
| 4 | heading_prefix "\\letter " | |
| 5 | numhead_positive "{}" | |
| 6 | symhead_positive "{}" | |
| 7 | item_0 "\n " | |
| 8 | item_1 "\n \\sub " | |
| 9 | item_01 "\n \\sub " | |
| 10 | item_x1 ", " | |
| 11 | item_2 "\n \\subsub " | |
| 12 | item_12 "\n \\subsub " | |
| 13 | item_x2 ", " | |
| 14 | page_compositor "--" | |
| 15 | line_max 1000 |
Binary diff not shown
| 0 | C grpsupp.tex 1. Supportive functions for groups | |
| 1 | S 1.1. Predefined groups | |
| 2 | F 1.1. TWGroup | |
| 3 | F 1.1. IdTWGroup | |
| 4 | S 1.2. Operation tables for groups | |
| 5 | F 1.2. PrintTable | |
| 6 | S 1.3. Group endomorphisms | |
| 7 | F 1.3. Endomorphisms | |
| 8 | S 1.4. Group automorphisms | |
| 9 | F 1.4. Automorphisms | |
| 10 | S 1.5. Inner automorphisms of a group | |
| 11 | F 1.5. InnerAutomorphisms | |
| 12 | S 1.6. Isomorphic groups | |
| 13 | F 1.6. IsIsomorphicGroup | |
| 14 | S 1.7. Subgroups of a group | |
| 15 | F 1.7. Subgroups | |
| 16 | S 1.8. Normal subgroups generated by a single element | |
| 17 | F 1.8. OneGeneratedNormalSubgroups | |
| 18 | S 1.9. Invariant subgroups | |
| 19 | F 1.9. IsInvariantUnderMaps | |
| 20 | F 1.9. IsCharacteristicSubgroup | |
| 21 | F 1.9. IsCharacteristicInParent | |
| 22 | F 1.9. IsFullinvariant | |
| 23 | F 1.9. IsFullinvariantInParent | |
| 24 | S 1.10. Coset representatives | |
| 25 | F 1.10. RepresentativesModNormalSubgroup | |
| 26 | F 1.10. NontrivialRepresentativesModNormalSubgroup | |
| 27 | S 1.11. Scott length | |
| 28 | F 1.11. ScottLength | |
| 29 | S 1.12. Other useful functions for groups | |
| 30 | F 1.12. AsPermGroup | |
| 31 | C nr.tex 2. Nearrings | |
| 32 | S 2.1. Defining a nearring multiplication | |
| 33 | F 2.1. IsNearRingMultiplication | |
| 34 | F 2.1. NearRingMultiplicationByOperationTable | |
| 35 | S 2.2. Construction of nearrings | |
| 36 | F 2.2. ExplicitMultiplicationNearRing | |
| 37 | F 2.2. ExplicitMultiplicationNearRingNC | |
| 38 | F 2.2. IsNearRing | |
| 39 | F 2.2. IsExplicitMultiplicationNearRing | |
| 40 | S 2.3. Direct products of nearrings | |
| 41 | F 2.3. DirectProductNearRing | |
| 42 | S 2.4. Operation tables for nearrings | |
| 43 | F 2.4. PrintTable!near rings | |
| 44 | S 2.5. Modified symbols for the operation tables | |
| 45 | F 2.5. SetSymbols | |
| 46 | F 2.5. SetSymbolsSupervised | |
| 47 | F 2.5. Symbols | |
| 48 | S 2.6. Accessing nearring elements | |
| 49 | F 2.6. AsNearRingElement | |
| 50 | F 2.6. AsGroupReductElement | |
| 51 | S 2.7. Nearring elements | |
| 52 | F 2.7. AsList!near rings | |
| 53 | F 2.7. AsSortedList!near rings | |
| 54 | F 2.7. Enumerator!near rings | |
| 55 | S 2.8. Random nearring elements | |
| 56 | F 2.8. Random!near ring element | |
| 57 | S 2.9. Nearring generators | |
| 58 | F 2.9. GeneratorsOfNearRing | |
| 59 | S 2.10. Size of a nearring | |
| 60 | F 2.10. Size!near rings | |
| 61 | S 2.11. The additive group of a nearring | |
| 62 | F 2.11. GroupReduct | |
| 63 | S 2.12. Nearring endomorphisms | |
| 64 | F 2.12. Endomorphisms!near rings | |
| 65 | S 2.13. Nearring automorphisms | |
| 66 | F 2.13. Automorphisms!near rings | |
| 67 | S 2.14. Isomorphic nearrings | |
| 68 | F 2.14. IsIsomorphicNearRing | |
| 69 | S 2.15. Subnearrings | |
| 70 | F 2.15. SubNearRings | |
| 71 | S 2.16. Invariant subnearrings | |
| 72 | F 2.16. InvariantSubNearRings | |
| 73 | S 2.17. Constructing subnearrings | |
| 74 | F 2.17. SubNearRingBySubgroupNC | |
| 75 | S 2.18. Intersection of nearrings | |
| 76 | F 2.18. Intersection!for nearrings | |
| 77 | S 2.19. Identity of a nearring | |
| 78 | F 2.19. Identity | |
| 79 | F 2.19. One | |
| 80 | F 2.19. IsNearRingWithOne | |
| 81 | S 2.20. Units of a nearring | |
| 82 | F 2.20. IsNearRingUnit | |
| 83 | F 2.20. NearRingUnits | |
| 84 | S 2.21. Distributivity in a nearring | |
| 85 | F 2.21. Distributors | |
| 86 | F 2.21. DistributiveElements | |
| 87 | F 2.21. IsDistributiveNearRing | |
| 88 | S 2.22. Elements of a nearring with special properties | |
| 89 | F 2.22. ZeroSymmetricElements | |
| 90 | F 2.22. IdempotentElements | |
| 91 | F 2.22. NilpotentElements | |
| 92 | F 2.22. QuasiregularElements | |
| 93 | F 2.22. RegularElements | |
| 94 | S 2.23. Special properties of a nearring | |
| 95 | F 2.23. IsAbelianNearRing | |
| 96 | F 2.23. IsAbstractAffineNearRing | |
| 97 | F 2.23. IsBooleanNearRing | |
| 98 | F 2.23. IsNilNearRing | |
| 99 | F 2.23. IsNilpotentNearRing | |
| 100 | F 2.23. IsNilpotentFreeNearRing | |
| 101 | F 2.23. IsCommutative | |
| 102 | F 2.23. IsDgNearRing | |
| 103 | F 2.23. IsIntegralNearRing | |
| 104 | F 2.23. IsPrimeNearRing | |
| 105 | F 2.23. IsQuasiregularNearRing | |
| 106 | F 2.23. IsRegularNearRing | |
| 107 | F 2.23. IsNearField | |
| 108 | F 2.23. IsPlanarNearRing | |
| 109 | F 2.23. IsWdNearRing | |
| 110 | C libnr.tex 3. The nearring library | |
| 111 | S 3.1. Extracting nearrings from the library | |
| 112 | F 3.1. LibraryNearRing | |
| 113 | F 3.1. NumberLibraryNearRings | |
| 114 | F 3.1. AllLibraryNearRings | |
| 115 | F 3.1. LibraryNearRingWithOne | |
| 116 | F 3.1. NumberLibraryNearRingsWithOne | |
| 117 | F 3.1. AllLibraryNearRingsWithOne | |
| 118 | S 3.2. Identifying nearrings | |
| 119 | F 3.2. IdLibraryNearRing | |
| 120 | F 3.2. IdLibraryNearRingWithOne | |
| 121 | S 3.3. IsLibraryNearRing | |
| 122 | F 3.3. IsLibraryNearRing | |
| 123 | S 3.4. Accessing the information about a nearring stored in the library | |
| 124 | F 3.4. LibraryNearRingInfo | |
| 125 | C tfms.tex 4. Arbitrary functions on groups: EndoMappings | |
| 126 | S 4.1. Defining endo mappings | |
| 127 | F 4.1. EndoMappingByPositionList | |
| 128 | F 4.1. EndoMappingByFunction | |
| 129 | F 4.1. AsEndoMapping | |
| 130 | F 4.1. AsGroupGeneralMappingByImages | |
| 131 | F 4.1. IsEndoMapping | |
| 132 | F 4.1. IdentityEndoMapping | |
| 133 | F 4.1. ConstantEndoMapping | |
| 134 | S 4.2. Properties of endo mappings | |
| 135 | F 4.2. IsIdentityEndoMapping | |
| 136 | F 4.2. IsConstantEndoMapping | |
| 137 | F 4.2. IsDistributiveEndoMapping | |
| 138 | S 4.3. Operations for endo mappings | |
| 139 | S 4.4. Nicer ways to print a mapping | |
| 140 | F 4.4. GraphOfMapping | |
| 141 | F 4.4. PrintAsTerm | |
| 142 | C tfmnr.tex 5. Transformation nearrings | |
| 143 | S 5.1. Constructing transformation nearrings | |
| 144 | F 5.1. TransformationNearRingByGenerators | |
| 145 | F 5.1. TransformationNearRingByAdditiveGenerators | |
| 146 | S 5.2. Nearrings of transformations | |
| 147 | F 5.2. MapNearRing | |
| 148 | F 5.2. TransformationNearRing | |
| 149 | F 5.2. IsFullTransformationNearRing | |
| 150 | F 5.2. PolynomialNearRing | |
| 151 | F 5.2. EndomorphismNearRing | |
| 152 | F 5.2. AutomorphismNearRing | |
| 153 | F 5.2. InnerAutomorphismNearRing | |
| 154 | F 5.2. CompatibleFunctionNearRing | |
| 155 | F 5.2. ZeroSymmetricCompatibleFunctionNearRing | |
| 156 | F 5.2. IsCompatibleEndoMapping | |
| 157 | F 5.2. Is1AffineComplete | |
| 158 | F 5.2. CentralizerNearRing | |
| 159 | F 5.2. RestrictedEndomorphismNearRing | |
| 160 | F 5.2. LocalInterpolationNearRing | |
| 161 | S 5.3. The group a transformation nearring acts on | |
| 162 | F 5.3. Gamma | |
| 163 | S 5.4. Transformation nearrings and other nearrings | |
| 164 | F 5.4. AsTransformationNearRing | |
| 165 | F 5.4. AsExplicitMultiplicationNearRing | |
| 166 | S 5.5. Noetherian quotients for transformation nearrings | |
| 167 | F 5.5. NoetherianQuotient!for transformation nearrings | |
| 168 | F 5.5. CongruenceNoetherianQuotient!for nearrings of polynomial functions | |
| 169 | F 5.5. CongruenceNoetherianQuotientForInnerAutomorphismNearRings !for inner automorphism nearrings | |
| 170 | S 5.6. Zerosymmetric mappings | |
| 171 | F 5.6. ZeroSymmetricPart!for transformation nearrings | |
| 172 | C ideals.tex 6. Nearring ideals | |
| 173 | S 6.1. Construction of nearring ideals | |
| 174 | F 6.1. NearRingIdealByGenerators | |
| 175 | F 6.1. NearRingLeftIdealByGenerators | |
| 176 | F 6.1. NearRingRightIdealByGenerators | |
| 177 | F 6.1. NearRingIdealBySubgroupNC | |
| 178 | F 6.1. NearRingLeftIdealBySubgroupNC | |
| 179 | F 6.1. NearRingRightIdealBySubgroupNC | |
| 180 | F 6.1. NearRingIdeals | |
| 181 | F 6.1. NearRingLeftIdeals | |
| 182 | F 6.1. NearRingRightIdeals | |
| 183 | S 6.2. Testing for ideal properties | |
| 184 | F 6.2. IsNRI | |
| 185 | F 6.2. IsNearRingLeftIdeal | |
| 186 | F 6.2. IsNearRingRightIdeal | |
| 187 | F 6.2. IsNearRingIdeal | |
| 188 | F 6.2. IsSubgroupNearRingLeftIdeal | |
| 189 | F 6.2. IsSubgroupNearRingRightIdeal | |
| 190 | S 6.3. Special ideal properties | |
| 191 | F 6.3. IsPrimeNearRingIdeal | |
| 192 | F 6.3. IsMaximalNearRingIdeal | |
| 193 | S 6.4. Generators of nearring ideals | |
| 194 | F 6.4. GeneratorsOfNearRingIdeal | |
| 195 | F 6.4. GeneratorsOfNearRingLeftIdeal | |
| 196 | F 6.4. GeneratorsOfNearRingRightIdeal | |
| 197 | S 6.5. Near-ring ideal elements | |
| 198 | F 6.5. AsList!near ring ideals | |
| 199 | F 6.5. AsSortedList!near ring ideals | |
| 200 | F 6.5. Enumerator!near ring ideals | |
| 201 | S 6.6. Random ideal elements | |
| 202 | F 6.6. Random!near ring ideal element | |
| 203 | S 6.7. Membership of an ideal | |
| 204 | F 6.7. in | |
| 205 | S 6.8. Size of ideals | |
| 206 | F 6.8. Size!near ring ideals | |
| 207 | S 6.9. Group reducts of ideals | |
| 208 | F 6.9. GroupReduct!near ring ideals | |
| 209 | S 6.10. Comparision of ideals | |
| 210 | F 6.10. = | |
| 211 | S 6.11. Operations with ideals | |
| 212 | F 6.11. Intersection!for nearring ideals | |
| 213 | F 6.11. Intersection | |
| 214 | F 6.11. ClosureNearRingLeftIdeal | |
| 215 | F 6.11. ClosureNearRingRightIdeal | |
| 216 | F 6.11. ClosureNearRingIdeal | |
| 217 | S 6.12. Commutators | |
| 218 | F 6.12. NearRingCommutator | |
| 219 | S 6.13. Simple nearrings | |
| 220 | F 6.13. IsSimpleNearRing | |
| 221 | S 6.14. Factor nearrings | |
| 222 | F 6.14. FactorNearRing | |
| 223 | F 6.14. / | |
| 224 | C xsonata.tex 7. Graphic ideal lattices (X-GAP only) | |
| 225 | F 7.0. GraphicIdealLattice | |
| 226 | C ngroups.tex 8. N-groups | |
| 227 | S 8.1. Construction of N-groups | |
| 228 | F 8.1. NGroup | |
| 229 | F 8.1. NGroupByNearRingMultiplication | |
| 230 | F 8.1. NGroupByApplication | |
| 231 | F 8.1. NGroupByRightIdealFactor | |
| 232 | S 8.2. Operation tables of N-groups | |
| 233 | F 8.2. PrintTable!for N-groups | |
| 234 | S 8.3. Functions for N-groups | |
| 235 | F 8.3. IsNGroup | |
| 236 | F 8.3. NearRingActingOnNGroup | |
| 237 | F 8.3. ActionOfNearRingOnNGroup | |
| 238 | S 8.4. N-subgroups | |
| 239 | F 8.4. NSubgroup | |
| 240 | F 8.4. NSubgroups | |
| 241 | F 8.4. IsNSubgroup | |
| 242 | S 8.5. N0-subgroups | |
| 243 | F 8.5. N0Subgroups | |
| 244 | S 8.6. Ideals of N-groups | |
| 245 | F 8.6. NIdeal | |
| 246 | F 8.6. NIdeals | |
| 247 | F 8.6. IsNIdeal | |
| 248 | F 8.6. IsSimpleNGroup | |
| 249 | F 8.6. IsN0SimpleNGroup | |
| 250 | S 8.7. Special properties of N-groups | |
| 251 | F 8.7. IsCompatible | |
| 252 | F 8.7. IsTameNGroup | |
| 253 | F 8.7. Is2TameNGroup | |
| 254 | F 8.7. Is3TameNGroup | |
| 255 | F 8.7. IsMonogenic | |
| 256 | F 8.7. IsStronglyMonogenic | |
| 257 | F 8.7. TypeOfNGroup | |
| 258 | S 8.8. Noetherian quotients | |
| 259 | F 8.8. NoetherianQuotient | |
| 260 | S 8.9. Nearring radicals | |
| 261 | F 8.9. NuRadical | |
| 262 | F 8.9. NuRadicals | |
| 263 | C fpf.tex 9. Fixed-point-free automorphism groups | |
| 264 | S 9.1. Fixed-point-free automorphism groups and Frobenius groups | |
| 265 | F 9.1. IsFpfAutomorphismGroup | |
| 266 | F 9.1. FpfAutomorphismGroupsMaxSize | |
| 267 | F 9.1. FrobeniusGroup | |
| 268 | S 9.2. Fixed-point-free representations | |
| 269 | F 9.2. IsFpfRepresentation | |
| 270 | F 9.2. DegreeOfIrredFpfRepCyclic | |
| 271 | F 9.2. DegreeOfIrredFpfRepMetacyclic | |
| 272 | F 9.2. DegreeOfIrredFpfRep2 | |
| 273 | F 9.2. DegreeOfIrredFpfRep3 | |
| 274 | F 9.2. DegreeOfIrredFpfRep4 | |
| 275 | F 9.2. FpfRepresentationsCyclic | |
| 276 | F 9.2. FpfRepresentationsMetacyclic | |
| 277 | F 9.2. FpfRepresentations2 | |
| 278 | F 9.2. FpfRepresentations3 | |
| 279 | F 9.2. FpfRepresentations4 | |
| 280 | S 9.3. Fixed-point-free automorphism groups | |
| 281 | F 9.3. FpfAutomorphismGroupsCyclic | |
| 282 | F 9.3. FpfAutomorphismGroupsMetacyclic | |
| 283 | F 9.3. FpfAutomorphismGroups2 | |
| 284 | F 9.3. FpfAutomorphismGroups3 | |
| 285 | F 9.3. FpfAutomorphismGroups4 | |
| 286 | C nfplwd.tex 10. Nearfields, planar nearrings and weakly divisible nearrings | |
| 287 | S 10.1. Dickson numbers | |
| 288 | F 10.1. IsPairOfDicksonNumbers | |
| 289 | S 10.2. Dickson nearfields | |
| 290 | F 10.2. DicksonNearFields | |
| 291 | F 10.2. NumberOfDicksonNearFields | |
| 292 | S 10.3. Exceptional nearfields | |
| 293 | F 10.3. ExceptionalNearFields | |
| 294 | F 10.3. AllExceptionalNearFields | |
| 295 | S 10.4. Planar nearrings | |
| 296 | F 10.4. PlanarNearRing | |
| 297 | F 10.4. OrbitRepresentativesForPlanarNearRing | |
| 298 | S 10.5. Weakly divisible nearrings | |
| 299 | F 10.5. WdNearRing | |
| 300 | C design.tex 11. Designs | |
| 301 | S 11.1. Constructing a design | |
| 302 | F 11.1. DesignFromPointsAndBlocks | |
| 303 | F 11.1. DesignFromIncidenceMat | |
| 304 | F 11.1. DesignFromPlanarNearRing | |
| 305 | F 11.1. DesignFromFerreroPair | |
| 306 | F 11.1. DesignFromWdNearRing | |
| 307 | S 11.2. Properties of a design | |
| 308 | F 11.2. PointsOfDesign | |
| 309 | F 11.2. BlocksOfDesign | |
| 310 | F 11.2. DesignParameter | |
| 311 | F 11.2. IncidenceMat | |
| 312 | F 11.2. PrintIncidenceMat | |
| 313 | F 11.2. BlockIntersectionNumbers | |
| 314 | F 11.2. BlockIntersectionNumbersK | |
| 315 | F 11.2. IsCircularDesign | |
| 316 | S 11.3. Working with the points and blocks of a design | |
| 317 | F 11.3. IsPointIncidentBlock | |
| 318 | F 11.3. PointsIncidentBlocks | |
| 319 | F 11.3. BlocksIncidentPoints |
| 0 | \chapcontents {\tocstrut }{Copyright notice}{5} | |
| 1 | \chapcontents {\tocstrut }{The authors}{6} | |
| 2 | \chapcontents {\tocstrut }{Preface}{7} | |
| 3 | \chapcontents {1}{Supportive functions for groups}{9} | |
| 4 | \seccontents {1.1}{Predefined groups} {9} | |
| 5 | \seccontents {1.2}{Operation tables for groups} {10} | |
| 6 | \seccontents {1.3}{Group endomorphisms} {10} | |
| 7 | \seccontents {1.4}{Group automorphisms} {11} | |
| 8 | \seccontents {1.5}{Inner automorphisms of a group} {11} | |
| 9 | \seccontents {1.6}{Isomorphic groups} {11} | |
| 10 | \seccontents {1.7}{Subgroups of a group} {12} | |
| 11 | \seccontents {1.8}{Normal subgroups generated by a single element} {12} | |
| 12 | \seccontents {1.9}{Invariant subgroups} {12} | |
| 13 | \seccontents {1.10}{Coset representatives} {13} | |
| 14 | \seccontents {1.11}{Scott length} {14} | |
| 15 | \seccontents {1.12}{Other useful functions for groups} {14} | |
| 16 | \chapcontents {2}{Nearrings}{15} | |
| 17 | \seccontents {2.1}{Defining a nearring multiplication} {15} | |
| 18 | \seccontents {2.2}{Construction of nearrings} {16} | |
| 19 | \seccontents {2.3}{Direct products of nearrings} {17} | |
| 20 | \seccontents {2.4}{Operation tables for nearrings} {17} | |
| 21 | \seccontents {2.5}{Modified symbols for the operation tables} {18} | |
| 22 | \seccontents {2.6}{Accessing nearring elements} {18} | |
| 23 | \seccontents {2.7}{Nearring elements} {19} | |
| 24 | \seccontents {2.8}{Random nearring elements} {20} | |
| 25 | \seccontents {2.9}{Nearring generators} {20} | |
| 26 | \seccontents {2.10}{Size of a nearring} {20} | |
| 27 | \seccontents {2.11}{The additive group of a nearring} {20} | |
| 28 | \seccontents {2.12}{Nearring endomorphisms} {20} | |
| 29 | \seccontents {2.13}{Nearring automorphisms} {21} | |
| 30 | \seccontents {2.14}{Isomorphic nearrings} {21} | |
| 31 | \seccontents {2.15}{Subnearrings} {21} | |
| 32 | \seccontents {2.16}{Invariant subnearrings} {21} | |
| 33 | \seccontents {2.17}{Constructing subnearrings} {22} | |
| 34 | \seccontents {2.18}{Intersection of nearrings} {22} | |
| 35 | \seccontents {2.19}{Identity of a nearring} {23} | |
| 36 | \seccontents {2.20}{Units of a nearring} {23} | |
| 37 | \seccontents {2.21}{Distributivity in a nearring} {24} | |
| 38 | \seccontents {2.22}{Elements of a nearring with special properties} {24} | |
| 39 | \seccontents {2.23}{Special properties of a nearring} {26} | |
| 40 | \chapcontents {3}{The nearring library}{29} | |
| 41 | \seccontents {3.1}{Extracting nearrings from the library} {29} | |
| 42 | \seccontents {3.2}{Identifying nearrings} {30} | |
| 43 | \seccontents {3.3}{IsLibraryNearRing} {30} | |
| 44 | \seccontents {3.4}{Accessing the information about a nearring stored in the library} {31} | |
| 45 | \chapcontents {4}{Arbitrary functions on groups: EndoMappings}{32} | |
| 46 | \seccontents {4.1}{Defining endo mappings} {32} | |
| 47 | \seccontents {4.2}{Properties of endo mappings} {34} | |
| 48 | \seccontents {4.3}{Operations for endo mappings} {34} | |
| 49 | \seccontents {4.4}{Nicer ways to print a mapping} {35} | |
| 50 | \chapcontents {5}{Transformation nearrings}{37} | |
| 51 | \seccontents {5.1}{Constructing transformation nearrings} {37} | |
| 52 | \seccontents {5.2}{Nearrings of transformations} {38} | |
| 53 | \seccontents {5.3}{The group a transformation nearring acts on} {41} | |
| 54 | \seccontents {5.4}{Transformation nearrings and other nearrings} {41} | |
| 55 | \seccontents {5.5}{Noetherian quotients for transformation nearrings} {41} | |
| 56 | \seccontents {5.6}{Zerosymmetric mappings} {42} | |
| 57 | \chapcontents {6}{Nearring ideals}{44} | |
| 58 | \seccontents {6.1}{Construction of nearring ideals} {44} | |
| 59 | \seccontents {6.2}{Testing for ideal properties} {46} | |
| 60 | \seccontents {6.3}{Special ideal properties} {47} | |
| 61 | \seccontents {6.4}{Generators of nearring ideals} {47} | |
| 62 | \seccontents {6.5}{Near-ring ideal elements} {48} | |
| 63 | \seccontents {6.6}{Random ideal elements} {48} | |
| 64 | \seccontents {6.7}{Membership of an ideal} {48} | |
| 65 | \seccontents {6.8}{Size of ideals} {48} | |
| 66 | \seccontents {6.9}{Group reducts of ideals} {49} | |
| 67 | \seccontents {6.10}{Comparision of ideals} {49} | |
| 68 | \seccontents {6.11}{Operations with ideals} {49} | |
| 69 | \seccontents {6.12}{Commutators} {49} | |
| 70 | \seccontents {6.13}{Simple nearrings} {50} | |
| 71 | \seccontents {6.14}{Factor nearrings} {50} | |
| 72 | \chapcontents {7}{Graphic ideal lattices (X-GAP only)}{51} | |
| 73 | \chapcontents {8}{N-groups}{52} | |
| 74 | \seccontents {8.1}{Construction of N-groups} {52} | |
| 75 | \seccontents {8.2}{Operation tables of N-groups} {53} | |
| 76 | \seccontents {8.3}{Functions for N-groups} {54} | |
| 77 | \seccontents {8.4}{N-subgroups} {55} | |
| 78 | \seccontents {8.5}{N0-subgroups} {55} | |
| 79 | \seccontents {8.6}{Ideals of N-groups} {55} | |
| 80 | \seccontents {8.7}{Special properties of N-groups} {56} | |
| 81 | \seccontents {8.8}{Noetherian quotients} {57} | |
| 82 | \seccontents {8.9}{Nearring radicals} {57} | |
| 83 | \chapcontents {9}{Fixed-point-free automorphism groups}{58} | |
| 84 | \seccontents {9.1}{Fixed-point-free automorphism groups and Frobenius groups} {58} | |
| 85 | \seccontents {9.2}{Fixed-point-free representations} {59} | |
| 86 | \seccontents {9.3}{Fixed-point-free automorphism groups} {64} | |
| 87 | \chapcontents {10}{Nearfields, planar nearrings and weakly divisible nearrings}{67} | |
| 88 | \seccontents {10.1}{Dickson numbers} {67} | |
| 89 | \seccontents {10.2}{Dickson nearfields} {67} | |
| 90 | \seccontents {10.3}{Exceptional nearfields} {68} | |
| 91 | \seccontents {10.4}{Planar nearrings} {69} | |
| 92 | \seccontents {10.5}{Weakly divisible nearrings} {70} | |
| 93 | \chapcontents {11}{Designs}{71} | |
| 94 | \seccontents {11.1}{Constructing a design} {71} | |
| 95 | \seccontents {11.2}{Properties of a design} {73} | |
| 96 | \seccontents {11.3}{Working with the points and blocks of a design} {74} | |
| 97 | \chapcontents {}{Bibliography}{76} |
| 1 | 1 | %% |
| 2 | 2 | %W copyrigh.tex GAP documentation LDFM |
| 3 | 3 | %W & SMCS |
| 4 | %% | |
| 5 | %H @(#)$Id: copyrigh.tex,v 1.3 2003/03/26 14:19:11 juergen Exp $ | |
| 6 | 4 | %% |
| 7 | 5 | %Y Copyright 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany |
| 8 | 6 | %% |
| 0 | \bibstyle{alpha} | |
| 1 | \bibdata{../ref/sonata} | |
| 2 | \citation{meldrum85:NATLWG} | |
| 3 | \citation{Clay:Nearrings} | |
| 4 | \citation{Ferrero:Nearrings} | |
| 5 | \citation{Pilz:Nearrings} | |
| 6 | \citation{Pilz:Nearrings} | |
| 7 | \citation{Waehling:Fastkoerper} | |
| 8 | \citation{Pilz:Nearrings} | |
| 9 | \citation{Pilz:Nearrings} | |
| 10 | \citation{Pilz:Nearrings} | |
| 11 | \citation{Pilz:Nearrings} | |
| 12 | \citation{meldrum85:NATLWG} | |
| 13 | \citation{thomaswood80:GT} | |
| 14 | \citation{Pilz:Nearrings} | |
| 15 | \citation{Clay:Nearrings} | |
| 16 | \citation{Clay:Nearrings} |
Binary diff not shown
| 0 | gap> LoadPackage( "sonata" ); | |
| 1 | gap> G := DihedralGroup( 8 ); | |
| 2 | <pc group of size 8 with 3 generators> | |
| 3 | gap> IdTWGroup( G ); | |
| 4 | [ 8, 4 ] | |
| 5 | gap> H := TWGroup( 8, 4 ); | |
| 6 | 8/4 | |
| 7 | gap> AsList( H ); | |
| 8 | [ (), (2,4), (1,2)(3,4), (1,2,3,4), (1,3), (1,3)(2,4), (1,4,3,2), | |
| 9 | (1,4)(2,3) ] | |
| 10 | gap> IsomorphismGroups(G,H); | |
| 11 | [ f1, f2, f3 ] -> [ (2,4), (1,2,3,4), (1,3)(2,4) ] | |
| 12 | gap> NumberSmallGroups( 32 ); | |
| 13 | 51 | |
| 14 | gap> GTW32_46; | |
| 15 | 32/46 | |
| 16 | gap> GTW32_46 = TWGroup( 32, 46 ); | |
| 17 | true | |
| 18 | gap> Filtered( GroupList, g -> not IsAbelian( g ) and | |
| 19 | > Size(Centre( g ))=1 ); | |
| 20 | [ 6/2, 10/2, 12/4, 14/2, 18/4, 18/5, 20/5, 21/2, 22/2, 24/12, 26/2, | |
| 21 | 30/4 ] | |
| 22 | gap> D16 := DihedralGroup( 16 ); | |
| 23 | <pc group of size 16 with 4 generators> | |
| 24 | gap> S := Subgroups( D16 ); | |
| 25 | [ Group([ ]), Group([ f4 ]), Group([ f1 ]), Group([ f1*f3 ]), | |
| 26 | Group([ f1*f4 ]), Group([ f1*f3*f4 ]), Group([ f1*f2 ]), | |
| 27 | Group([ f1*f2*f3 ]), Group([ f1*f2*f4 ]), | |
| 28 | Group([ f1*f2*f3*f4 ]), Group([ f4, f3 ]), Group([ f4, f1 ]), | |
| 29 | Group([ f1*f3, f4 ]), Group([ f4, f1*f2 ]), | |
| 30 | Group([ f1*f2*f3, f4 ]), Group([ f4, f3, f1 ]), | |
| 31 | Group([ f4, f3, f2 ]), Group([ f4, f3, f1*f2 ]), | |
| 32 | Group([ f4, f3, f1, f2 ]) ] | |
| 33 | gap> C := Filtered( S, G -> IsCharacteristicInParent( G ) ); | |
| 34 | [ Group([ ]), Group([ f4 ]), Group([ f4, f3 ]), Group([ f4, f3, f2 ]), | |
| 35 | Group([ f4, f3, f1, f2 ]) ] | |
| 36 | gap> G := GTW6_2; | |
| 37 | 6/2 | |
| 38 | gap> Automorphisms( G ); | |
| 39 | [ IdentityMapping( 6/2 ), ^(2,3), ^(1,3), ^(1,3,2), ^(1,2,3), ^(1,2) ] | |
| 40 | gap> Endos := Endomorphisms( G ); | |
| 41 | [ [ (1,2), (1,2,3) ] -> [ (), () ], [ (1,2), (1,2,3) ] -> [ (2,3), () ], | |
| 42 | [ (1,2), (1,2,3) ] -> [ (1,3), () ], [ (1,2), (1,2,3) ] -> [ (1,2), () ], | |
| 43 | [ (1,2), (1,2,3) ] -> [ (2,3), (1,2,3) ], | |
| 44 | [ (1,2), (1,2,3) ] -> [ (2,3), (1,3,2) ], | |
| 45 | [ (1,2), (1,2,3) ] -> [ (1,2), (1,3,2) ], | |
| 46 | [ (1,2), (1,2,3) ] -> [ (1,2), (1,2,3) ], | |
| 47 | [ (1,2), (1,2,3) ] -> [ (1,3), (1,2,3) ], | |
| 48 | [ (1,2), (1,2,3) ] -> [ (1,3), (1,3,2) ] ] | |
| 49 | gap> IsFixedpointfree := function( endo ) | |
| 50 | >local group; | |
| 51 | > group := Source( endo ); # the domain of endo | |
| 52 | > return ForAll( group, x -> (x <> x^endo) or (x = Identity(group)) ); | |
| 53 | > # x is not fixed or x is the identity | |
| 54 | >end; | |
| 55 | function ( endo ) ... end | |
| 56 | gap> e := Endos[4]; | |
| 57 | [ (1,2), (1,2,3) ] -> [ (1,2), () ] | |
| 58 | gap> IsFixedpointfree( e ); | |
| 59 | false | |
| 60 | gap> Filtered( Endos, IsFixedpointfree ); | |
| 61 | [ [ (1,2), (1,2,3) ] -> [ (), () ] ] | |
| 62 | gap> G := GTW16_11; | |
| 63 | 16/11 | |
| 64 | gap> F := FrattiniSubgroup( G ); | |
| 65 | Group([ (1,4,11,14)(2,7,10,16)(3,8,15,9)(5,12,6,13) ]) | |
| 66 | gap> NontrivialRepresentativesModNormalSubgroup( G, F ); | |
| 67 | [ (1,16,14,10,11,7,4,2)(3,12,9,5,15,13,8,6), | |
| 68 | (1,3)(2,5)(4,8)(6,10)(7,12)(9,14)(11,15)(13,16), | |
| 69 | (1,13,4,5,11,12,14,6)(2,3,7,8,10,15,16,9) ] | |
| 70 | gap> H := Group( last ); | |
| 71 | Group([ (1,16,14,10,11,7,4,2)(3,12,9,5,15,13,8,6), | |
| 72 | (1,3)(2,5)(4,8)(6,10)(7,12)(9,14)(11,15)(13,16), | |
| 73 | (1,13,4,5,11,12,14,6)(2,3,7,8,10,15,16,9) ]) | |
| 74 | gap> G = H; # test | |
| 75 | true |
| 0 | gap> G := GTW4_2; | |
| 1 | 4/2 | |
| 2 | gap> AsSortedList( G ); | |
| 3 | [ (), (3,4), (1,2), (1,2)(3,4) ] | |
| 4 | gap> SetSymbols( G, [ "0", "a", "b", "c" ] ); | |
| 5 | gap> PrintTable( G ); | |
| 6 | Let: | |
| 7 | 0 := () | |
| 8 | a := (3,4) | |
| 9 | b := (1,2) | |
| 10 | c := (1,2)(3,4) | |
| 11 | ||
| 12 | + \ 0 a b c | |
| 13 | ------------ | |
| 14 | 0 \ 0 a b c | |
| 15 | a \ a 0 c b | |
| 16 | b \ b c 0 a | |
| 17 | c \ c b a 0 | |
| 18 | ||
| 19 | gap> table := [ [ 1, 1, 1, 1 ], | |
| 20 | > [ 1, 1, 2, 2 ], | |
| 21 | > [ 1, 2, 4, 3 ], | |
| 22 | > [ 1, 2, 3, 4 ] ]; | |
| 23 | [ [ 1, 1, 1, 1 ], [ 1, 1, 2, 2 ], [ 1, 2, 4, 3 ], [ 1, 2, 3, 4 ] ] | |
| 24 | gap> mul:=NearRingMultiplicationByOperationTable( | |
| 25 | > G, table, AsSortedList(G) ); | |
| 26 | function( x, y ) ... end | |
| 27 | gap> N := ExplicitMultiplicationNearRing( G, mul ); | |
| 28 | ExplicitMultiplicationNearRing ( 4/2 , multiplication ) | |
| 29 | gap> PrintTable( N ); | |
| 30 | Let: | |
| 31 | 0 := (()) | |
| 32 | a := ((3,4)) | |
| 33 | b := ((1,2)) | |
| 34 | c := ((1,2)(3,4)) | |
| 35 | ||
| 36 | + \ 0 a b c | |
| 37 | --------------- | |
| 38 | 0 \ 0 a b c | |
| 39 | a \ a 0 c b | |
| 40 | b \ b c 0 a | |
| 41 | c \ c b a 0 | |
| 42 | ||
| 43 | * \ 0 a b c | |
| 44 | --------------- | |
| 45 | 0 \ 0 0 0 0 | |
| 46 | a \ 0 0 a a | |
| 47 | b \ 0 a c b | |
| 48 | c \ 0 a b c | |
| 49 | gap> IsNearField( N ); | |
| 50 | false | |
| 51 | gap> IsIntegralNearRing( N ); | |
| 52 | false | |
| 53 | gap> IsNilpotentNearRing( N ); | |
| 54 | false | |
| 55 | gap> t := GroupGeneralMappingByImages( | |
| 56 | > G, G, AsSortedList(G), AsSortedList(G){[1,2,4,3]} ); | |
| 57 | [ (), (3,4), (1,2), (1,2)(3,4) ] -> [ (), (3,4), (1,2)(3,4), (1,2) ] | |
| 58 | gap> id := IdentityMapping( G ); | |
| 59 | IdentityMapping( 4/2 ) | |
| 60 | gap> T := TransformationNearRingByGenerators( G, [t,id] ); | |
| 61 | TransformationNearRingByGenerators( | |
| 62 | [ [ (), (3,4), (1,2), (1,2)(3,4) ] -> [ (), (3,4), (1,2)(3,4), (1,2) ], | |
| 63 | IdentityMapping( 4/2 ) ]) | |
| 64 | gap> PrintTable(T); | |
| 65 | Let: | |
| 66 | n0 := <mapping: 4/2 -> 4/2 > | |
| 67 | n1 := <mapping: 4/2 -> 4/2 > | |
| 68 | n2 := <mapping: 4/2 -> 4/2 > | |
| 69 | n3 := <mapping: 4/2 -> 4/2 > | |
| 70 | ||
| 71 | + \ n0 n1 n2 n3 | |
| 72 | -------------------- | |
| 73 | n0 \ n0 n1 n2 n3 | |
| 74 | n1 \ n1 n0 n3 n2 | |
| 75 | n2 \ n2 n3 n0 n1 | |
| 76 | n3 \ n3 n2 n1 n0 | |
| 77 | ||
| 78 | * \ n0 n1 n2 n3 | |
| 79 | -------------------- | |
| 80 | n0 \ n0 n0 n0 n0 | |
| 81 | n1 \ n0 n0 n1 n1 | |
| 82 | n2 \ n0 n1 n2 n3 | |
| 83 | n3 \ n0 n1 n3 n2 | |
| 84 | gap> IsIsomorphicNearRing( N, T ); | |
| 85 | true | |
| 86 | gap> N = T; | |
| 87 | false |
| 0 | gap> NumberLibraryNearRings( GTW12_3 ); | |
| 1 | 48137 | |
| 2 | gap> NumberLibraryNearRingsWithOne( GTW4_1 ); | |
| 3 | 1 | |
| 4 | gap> Filtered( AllLibraryNearRingsWithOne( GTW4_1 ), | |
| 5 | > n -> not IsDistributiveNearRing( n ) ); | |
| 6 | [ ] | |
| 7 | gap> NumberLibraryNearRingsWithOne( GTW4_2 ); | |
| 8 | 5 | |
| 9 | gap> Filtered( AllLibraryNearRingsWithOne( GTW4_2 ), | |
| 10 | > n -> not IsDistributiveNearRing( n ) ); | |
| 11 | [ LibraryNearRing(4/2, 12), LibraryNearRing(4/2, 22) ] | |
| 12 | gap> PrintTable( LibraryNearRing( GTW4_2, 12 ) ); | |
| 13 | Let: | |
| 14 | n0 := (()) | |
| 15 | n1 := ((3,4)) | |
| 16 | n2 := ((1,2)) | |
| 17 | n3 := ((1,2)(3,4)) | |
| 18 | ||
| 19 | + \ n0 n1 n2 n3 | |
| 20 | -------------------- | |
| 21 | n0 \ n0 n1 n2 n3 | |
| 22 | n1 \ n1 n0 n3 n2 | |
| 23 | n2 \ n2 n3 n0 n1 | |
| 24 | n3 \ n3 n2 n1 n0 | |
| 25 | ||
| 26 | * \ n0 n1 n2 n3 | |
| 27 | -------------------- | |
| 28 | n0 \ n0 n0 n0 n0 | |
| 29 | n1 \ n0 n0 n1 n1 | |
| 30 | n2 \ n0 n0 n2 n2 | |
| 31 | n3 \ n0 n1 n2 n3 | |
| 32 | gap> PrintTable( LibraryNearRing( GTW4_2, 22 ) ); | |
| 33 | Let: | |
| 34 | n0 := (()) | |
| 35 | n1 := ((3,4)) | |
| 36 | n2 := ((1,2)) | |
| 37 | n3 := ((1,2)(3,4)) | |
| 38 | ||
| 39 | + \ n0 n1 n2 n3 | |
| 40 | -------------------- | |
| 41 | n0 \ n0 n1 n2 n3 | |
| 42 | n1 \ n1 n0 n3 n2 | |
| 43 | n2 \ n2 n3 n0 n1 | |
| 44 | n3 \ n3 n2 n1 n0 | |
| 45 | ||
| 46 | * \ n0 n1 n2 n3 | |
| 47 | -------------------- | |
| 48 | n0 \ n0 n0 n2 n2 | |
| 49 | n1 \ n0 n1 n2 n3 | |
| 50 | n2 \ n0 n2 n2 n0 | |
| 51 | n3 \ n0 n3 n2 n1 | |
| 52 | gap> nr_list := [ ]; | |
| 53 | [ ] | |
| 54 | gap> for i in [1..NumberLibraryNearRings( GTW8_4 )] do | |
| 55 | > n := LibraryNearRing( GTW8_4, i ); | |
| 56 | > if ( not IsZeroSymmetricNearRing( n ) or | |
| 57 | > IsIntegralNearRing( n ) or | |
| 58 | > Identity( n ) <> fail | |
| 59 | > ) then | |
| 60 | > Add( nr_list, n ); | |
| 61 | > fi; | |
| 62 | > od; | |
| 63 | gap> Length( nr_list ); | |
| 64 | 141 | |
| 65 | gap> Filtered( nr_list, IsBooleanNearRing ); | |
| 66 | [ LibraryNearRing(8/4, 1314), LibraryNearRing(8/4, 1380), | |
| 67 | LibraryNearRing(8/4, 1446), LibraryNearRing(8/4, 1447) ] |
| 0 | gap> A4 := AlternatingGroup( 4 ); | |
| 1 | Alt( [ 1 .. 4 ] ) | |
| 2 | gap> AsSortedList( A4 ); | |
| 3 | [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), | |
| 4 | (1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ] | |
| 5 | t := EndoMappingByPositionList( A4, [1,3,4,5,2,1,1,1,1,1,1,1] ); | |
| 6 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 7 | [ 1 .. 4 ] ) > | |
| 8 | gap> t+t; | |
| 9 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 10 | [ 1 .. 4 ] ) > | |
| 11 | gap> last * t; | |
| 12 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 13 | [ 1 .. 4 ] ) > | |
| 14 | gap> T := TransformationNearRingByGenerators( A4, [ t ] );; | |
| 15 | gap> Size( T ); | |
| 16 | 20736 | |
| 17 | gap> F := Filtered( T, tfm -> Image( tfm, (1,2,3) ) = (1,2,3) );; | |
| 18 | gap> Length( F ); | |
| 19 | 1728 | |
| 20 | gap> Random( F );; | |
| 21 | gap> IsCommutative( T ); | |
| 22 | false | |
| 23 | gap> g := CyclicGroup(2);; | |
| 24 | gap> m := MapNearRing(g);; | |
| 25 | gap> Filtered( m, n -> not( IsCommutative( | |
| 26 | > TransformationNearRingByGenerators( g, [n] ) ) ) ); | |
| 27 | gap> [ <mapping: Group( [ f1 ] ) -> Group( [ f1 ] ) >, | |
| 28 | <mapping: Group( [ f1 ] ) -> Group( [ f1 ] ) > ] | |
| 29 | gap> GraphOfMapping(last[1]); | |
| 30 | [ [ <identity> of ..., f1 ], [ f1, <identity> of ... ] ] |
| 0 | gap> I := InnerAutomorphismNearRing ( AlternatingGroup ( 4 ) ); | |
| 1 | InnerAutomorphismNearRing( Alt( [ 1 .. 4 ] ) ) | |
| 2 | gap> Size (I); | |
| 3 | 3072 | |
| 4 | gap> p := Random( I ); | |
| 5 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( [ 1 .. 4 ] ) > | |
| 6 | gap> PrintAsTerm( p ); | |
| 7 | - g1 + g2 - x - g2 + g1 + g2 + g1 - x + g2 - x + 2 * g1 - | |
| 8 | 3 * x - g1 + x + g2 - x - g2 + g1 + x - g1 + x - g1 + x + | |
| 9 | g1 + x - g2 - x + g2 - g1 - x + g1 + x | |
| 10 | gap> GeneratorsOfGroup( AlternatingGroup( 4 ) ); | |
| 11 | [ (1,2,3), (2,3,4) ] | |
| 12 | gap> A := AutomorphismNearRing ( DihedralGroup ( 8 ) ); | |
| 13 | AutomorphismNearRing( <pc group of size 8 with 3 generators> ) | |
| 14 | gap> Size (A); | |
| 15 | 32 | |
| 16 | gap> EndS4 := EndomorphismNearRing ( SymmetricGroup ( 4 ) ); | |
| 17 | EndomorphismNearRing( Sym( [ 1 .. 4 ] ) ) | |
| 18 | gap> Size ( EndS4 ); | |
| 19 | 927712935936 | |
| 20 | gap> F1 := last;; | |
| 21 | gap> Collected ( Factors( F1 )); | |
| 22 | [ [ 2, 35 ], [ 3, 3 ] ] | |
| 23 | gap> G := GTW16_8; | |
| 24 | 16/8 | |
| 25 | gap> U := First ( NormalSubgroups( G ), N -> Size(N) = 2 ); | |
| 26 | Group([ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) | |
| 27 | gap> HGU := RestrictedEndomorphismNearRing (G, U); | |
| 28 | RestrictedEndomorphismNearRing( 16/8, Group( | |
| 29 | [ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) ) | |
| 30 | gap> Size (HGU); | |
| 31 | 8 | |
| 32 | gap> EofG := EndomorphismNearRing ( G ); | |
| 33 | EndomorphismNearRing( 16/8 ) | |
| 34 | gap> EGU := NoetherianQuotient ( EofG, U, G ); | |
| 35 | NoetherianQuotient( Group( | |
| 36 | [ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) ,16/8 ) | |
| 37 | gap> Size ( EGU ); | |
| 38 | 128 | |
| 39 | gap> G := SymmetricGroup ( 3 ); | |
| 40 | Sym( [ 1 .. 3 ] ) | |
| 41 | gap> I := InnerAutomorphismNearRing ( G ); | |
| 42 | InnerAutomorphismNearRing( Sym( [ 1 .. 3 ] ) ) | |
| 43 | gap> Size( I ); | |
| 44 | 54 | |
| 45 | gap> Filtered ( I, | |
| 46 | > t -> ForAll( G, g -> Image(t, g) = Image(t, Image(t, g)) ) );; | |
| 47 | gap> Length( last ); | |
| 48 | 18 | |
| 49 | gap> Filtered ( I, i -> i^2 = i );; | |
| 50 | gap> Length( last ); | |
| 51 | 18 | |
| 52 | gap> G := SymmetricGroup( 3 ); | |
| 53 | Sym( [ 1 .. 3 ] ) | |
| 54 | gap> endos := Endomorphisms( G ); | |
| 55 | [ [ (1,2,3), (1,2) ] -> [ (), () ], [ (1,2,3), (1,2) ] -> [ (), (1,3) ], | |
| 56 | [ (1,2,3), (1,2) ] -> [ (), (2,3) ], [ (1,2,3), (1,2) ] -> [ (), (1,2) ], | |
| 57 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,3) ], | |
| 58 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,2) ], | |
| 59 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,3) ], | |
| 60 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (2,3) ], | |
| 61 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,2) ], | |
| 62 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (2,3) ] ] | |
| 63 | gap> C := CentralizerNearRing( G, endos ); | |
| 64 | CentralizerNearRing( Sym( [ 1 .. 3 ] ), ... ) | |
| 65 | gap> Size ( C ); | |
| 66 | 6 | |
| 67 | gap> I := NearRingIdeals( C ); | |
| 68 | [ < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 69 | < nearring ideal > ] | |
| 70 | gap> List( I, Size ); | |
| 71 | [ 1, 2, 3, 6 ] | |
| 72 | gap> P := PolynomialNearRing( GTW16_6 ); | |
| 73 | PolynomialNearRing( 16/6 ) | |
| 74 | gap> Size( P ); | |
| 75 | 256 | |
| 76 | gap> C := LocalInterpolationNearRing(P, 2); | |
| 77 | LocalInterpolationNearRing( PolynomialNearRing( 16/6 ), 2 ) | |
| 78 | gap> Size (C); | |
| 79 | 256 | |
| 80 | gap> C := CompatibleFunctionNearRing( GTW16_6 ); | |
| 81 | < transformation nearring with 7 generators > | |
| 82 | gap> Size(C); | |
| 83 | 256; | |
| 84 | gap> Is1AffineComplete( GTW16_6 ); | |
| 85 | true | |
| 86 | gap> ScottLength( SymmetricGroup( 3 ) ); | |
| 87 | 2 |
| 0 | gap> A := LibraryNearRing( GTW8_2, 12 ); | |
| 1 | LibraryNearRing(8/2, 12) | |
| 2 | gap> B := LibraryNearRing( GTW12_4, 13 ); | |
| 3 | LibraryNearRing(12/4, 13) | |
| 4 | gap> D := DirectProductNearRing( A, B ); | |
| 5 | DirectProductNearRing( LibraryNearRing(8/2, 12), | |
| 6 | LibraryNearRing(12/4, 13) ) | |
| 7 | gap> SetName( D, "A x B" ); | |
| 8 | gap> D; | |
| 9 | A x B | |
| 10 | gap> elms := AsSortedList( D );; | |
| 11 | gap> gens := elms{[2,25]}; | |
| 12 | [ (( 8, 9,10)), ((3,5)(4,6)) ] | |
| 13 | gap> L := NearRingLeftIdealByGenerators( D, gens ); | |
| 14 | < nearring left ideal > | |
| 15 | gap> Size( L ); | |
| 16 | 24 | |
| 17 | gap> IsNearRingRightIdeal( L ); | |
| 18 | true | |
| 19 | gap> L; | |
| 20 | < nearring ideal of size 24 > | |
| 21 | gap> IsMaximalNearRingIdeal( L ); | |
| 22 | false | |
| 23 | gap> F := D/L; | |
| 24 | FactorNearRing( A x B, < nearring ideal of size 24 > ) | |
| 25 | gap> PrintTable( F, "am" ); | |
| 26 | ||
| 27 | + \ n0 n1 n2 n3 | |
| 28 | -------------------- | |
| 29 | n0 \ n0 n1 n2 n3 | |
| 30 | n1 \ n1 n0 n3 n2 | |
| 31 | n2 \ n2 n3 n0 n1 | |
| 32 | n3 \ n3 n2 n1 n0 | |
| 33 | ||
| 34 | * \ n0 n1 n2 n3 | |
| 35 | -------------------- | |
| 36 | n0 \ n0 n0 n0 n0 | |
| 37 | n1 \ n0 n0 n0 n0 | |
| 38 | n2 \ n0 n0 n0 n0 | |
| 39 | n3 \ n0 n0 n0 n0 | |
| 40 | gap> IsElementaryAbelian( GroupReduct( F ) ); | |
| 41 | true | |
| 42 | gap> # this would also convince us | |
| 43 | gap> IsCyclic( GroupReduct( F ) ); | |
| 44 | false | |
| 45 | gap> SetSymbols( F, ["(0,0)","(0,1)","(1,0)","(1,1)"] ); | |
| 46 | gap> PrintTable( F, "m" ); | |
| 47 | ||
| 48 | * \ (0,0) (0,1) (1,0) (1,1) | |
| 49 | ----------------------------------- | |
| 50 | (0,0) \ (0,0) (0,0) (0,0) (0,0) | |
| 51 | (0,1) \ (0,0) (0,0) (0,0) (0,0) | |
| 52 | (1,0) \ (0,0) (0,0) (0,0) (0,0) | |
| 53 | (1,1) \ (0,0) (0,0) (0,0) (0,0) |
| 0 | gap> FpfAutomorphismGroupsMaxSize( CyclicGroup(25) ); | |
| 1 | [ 4, 1 ] | |
| 2 | gap> FpfAutomorphismGroupsMaxSize( ElementaryAbelianGroup(25) ); | |
| 3 | [ 24, 2 ] | |
| 4 | gap> aux := FpfAutomorphismGroupsMetacyclic( [5,5], 4, -1 ); | |
| 5 | [ [ [ [ f1, f2 ] -> [ f1^2, f2^3 ], [ f1, f2 ] -> [ f2^4, f1 ] ] ], | |
| 6 | <pc group of size 25 with 2 generators> ] | |
| 7 | gap> phi := Group( aux[1][1] ); | |
| 8 | <group with 2 generators> | |
| 9 | gap> G := aux[2]; | |
| 10 | <pc group of size 25 with 2 generators> | |
| 11 | gap> OrbitRepresentativesForPlanarNearRing( G, phi, 1 ); | |
| 12 | [ [ f1 ] ] | |
| 13 | gap> reps := OrbitRepresentativesForPlanarNearRing( G, phi, 2 ); | |
| 14 | [ [ f1, f1*f2 ], [ f1, f1^2*f2^2 ] ] | |
| 15 | gap> n := PlanarNearRing( G, phi, reps[1] ); | |
| 16 | ExplicitMultiplicationNearRing ( <pc group of size 25 with | |
| 17 | 2 generators> , multiplication ) | |
| 18 | gap> Length(OrbitRepresentativesForPlanarNearRing( G, phi, 3 )); | |
| 19 | 6 |
| 0 | gap> aux := FpfAutomorphismGroupsCyclic( [2,2,2,2], 5 ); | |
| 1 | [ [ [ f1, f2, f3, f4 ] -> [ f4, f1*f2, f2*f3, f3*f4 ] ], | |
| 2 | <pc group of size 16 with 4 generators> ] | |
| 3 | gap> a := aux[1][1]; | |
| 4 | [ f1, f2, f3, f4 ] -> [ f4, f1*f2, f2*f3, f3*f4 ] | |
| 5 | gap> phi := Group( a );; | |
| 6 | gap> G := aux[2];; | |
| 7 | gap> D := DesignFromFerreroPair( G, phi, "*" ); | |
| 8 | <a 2 - ( 16, 5, 4 ) nearring generated design> | |
| 9 | gap> D; | |
| 10 | <a 2 - ( 16, 5, 4 ) nearring generated design> | |
| 11 | gap> DesignParameter( D ); | |
| 12 | [ 2, 16, 48, 15, 5, 4 ] | |
| 13 | gap> PrintIncidenceMat( D ); | |
| 14 | ...1...1...11...1...1..1..11..1...1..1..1...11.. | |
| 15 | 1......1...1..1.1...11...1..1..1...11..1..1....1 | |
| 16 | .1..1......11..1...1..1...11....1..1..11..1...1. | |
| 17 | ..1..1..1...1...1.1...1..1...11...1.1....11...1. | |
| 18 | 1....11..1......1..1.1....1.1...11...1...1..1.1. | |
| 19 | .1..1.1...1..1......11....1..11....11....1.1.1.. | |
| 20 | ..1..1.1.1...1...1...1...1.1....1.1...11...1.1.. | |
| 21 | ..11...1..1.1..1..1.....1...1...1..1.1...1.1...1 | |
| 22 | ..1.1...1.1...1..1.1.1.....1..1..1...1..1.1....1 | |
| 23 | 1...1.1....1.1...11...1.1.......1.1.1...1...1..1 | |
| 24 | 1...1...11....11....1..11....1....1..1.1...1..1. | |
| 25 | .1...1..1.1.1....1.1...11...1..1....1..1....11.. | |
| 26 | .1.1....11...1.1....1.1..1.1...1.1.......1..1..1 | |
| 27 | .1.1..1....1..1..11....1.1..1.1..1....1....1..1. | |
| 28 | ..11..1..1....1.1..1..1.1....1.1...1..1.1....1.. | |
| 29 | 1....1.1..1..1.1..1....1..1..1.1.1....1.1.1..... | |
| 30 | gap> IsCircularDesign( D ); | |
| 31 | true | |
| 32 | gap> PointsIncidentBlocks( D, [2,7] ); | |
| 33 | [ 6, 14 ] | |
| 34 | gap> BlocksIncidentPoints( D, [6,14] ); | |
| 35 | [ 2, 7, 31, 44 ] | |
| 36 | gap> BlockIntersectionNumbers( D, 4 ); | |
| 37 | [ 0, 2, 2, 5, 0, 0, 2, 2, 1, 2, 1, 2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 0, | |
| 38 | 2, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 1, 2, 0, 2, 2, 0, 2, 2, 0, 2, | |
| 39 | 2, 2, 1, 2 ] |
| 0 | \indexentry {Thomas' and Wood's catalogue of small groups@Thomas' and Wood's catalogue of small groups|indexit}{4} | |
| 1 | \indexentry {Subgroups@Subgroups|indexit}{5} | |
| 2 | \indexentry {Group endomorphisms@Group endomorphisms|indexit}{5} | |
| 3 | \indexentry {Finding a set of generators@Finding a set of generators|indexit}{6} | |
| 4 | \indexentry {Entering nearrings into the system@Entering nearrings into the system|indexit}{7} | |
| 5 | \indexentry {Some simple questions about the nearring@Some simple questions about the nearring|indexit}{8} | |
| 6 | \indexentry {Entering the nearring with less typing@Entering the nearring with less typing|indexit}{9} | |
| 7 | \indexentry {An application of the nearring library@An application of the nearring library|indexit}{10} | |
| 8 | \indexentry {Appendix K revisited@Appendix K revisited|indexit}{11} | |
| 9 | \indexentry {Nearrings generated by endomorphisms on a group@Nearrings generated by endomorphisms on a group|indexit}{15} | |
| 10 | \indexentry {More information than just the size@More information than just the size|indexit}{16} | |
| 11 | \indexentry {Centralizer nearrings@Centralizer nearrings|indexit}{17} | |
| 12 | \indexentry {Finding affine complete groups@Finding affine complete groups|indexit}{18} | |
| 13 | \indexentry {Direct products@Direct products|indexit}{19} | |
| 14 | \indexentry {Ideals and factors@Ideals and factors|indexit}{20} | |
| 15 | \indexentry {Designs from planar nearrings@Designs from planar nearrings|indexit}{24} | |
| 16 | \indexentry {Information on designs@Information on designs|indexit}{25} |
| 0 | \makelabel{etudes:The authors}{{\setbox 0=\hbox {1}\vrule width 0pt height\ht 0}} | |
| 1 | \makelabel{etudes:Groups}{1} | |
| 2 | \makelabel{etudes:Thomas' and Wood's catalogue of small groups}{1.1} | |
| 3 | \makelabel{etudes:Subgroups}{1.2} | |
| 4 | \makelabel{etudes:Group endomorphisms}{1.3} | |
| 5 | \makelabel{etudes:Finding a set of generators}{1.4} | |
| 6 | \makelabel{etudes:Nearrings}{2} | |
| 7 | \makelabel{etudes:Entering nearrings into the system}{2.1} | |
| 8 | \makelabel{etudes:Some simple questions about the nearring}{2.2} | |
| 9 | \makelabel{etudes:Entering the nearring with less typing}{2.3} | |
| 10 | \makelabel{etudes:The nearring library}{3} | |
| 11 | \makelabel{etudes:An application of the nearring library}{3.1} | |
| 12 | \makelabel{etudes:Appendix K revisited}{3.2} | |
| 13 | \makelabel{etudes:Nearrings of transformations on groups}{4} | |
| 14 | \makelabel{etudes:Some interesting nearrings}{5} | |
| 15 | \makelabel{etudes:Nearrings generated by endomorphisms on a group}{5.1} | |
| 16 | \makelabel{etudes:More information than just the size}{5.2} | |
| 17 | \makelabel{etudes:Centralizer nearrings}{5.3} | |
| 18 | \makelabel{etudes:Finding affine complete groups}{5.4} | |
| 19 | \makelabel{etudes:Ideals, factors, and direct products of nearrings}{6} | |
| 20 | \makelabel{etudes:Direct products}{6.1} | |
| 21 | \makelabel{etudes:Ideals and factors}{6.2} | |
| 22 | \makelabel{etudes:Planar nearrings}{7} | |
| 23 | \makelabel{etudes:Designs}{8} | |
| 24 | \makelabel{etudes:Designs from planar nearrings}{8.1} | |
| 25 | \makelabel{etudes:Information on designs}{8.2} | |
| 26 | \makelabel{etudes:Bibliography}{} | |
| 27 | \makelabel{etudes:Index}{} |
| 0 | This is pdfTeX, Version 3.14159265-2.6-1.40.17 (TeX Live 2016) (preloaded format=pdftex 2017.5.16) 7 OCT 2018 20:24 | |
| 1 | entering extended mode | |
| 2 | restricted \write18 enabled. | |
| 3 | %&-line parsing enabled. | |
| 4 | **manual | |
| 5 | (./manual.tex (../gapmacro.tex | |
| 6 | (/usr/local/texlive/2016/texmf-dist/tex/plain/amsfonts/amssym.tex | |
| 7 | (/usr/local/texlive/2016/texmf-dist/tex/plain/amsfonts/amssym.def | |
| 8 | \msafam=\fam8 | |
| 9 | \msbfam=\fam9 | |
| 10 | \eufmfam=\fam10 | |
| 11 | )) | |
| 12 | Running PDFTeX | |
| 13 | \pagewidth=\dimen16 | |
| 14 | \pageheight=\dimen17 | |
| 15 | \colwidth=\dimen18 | |
| 16 | \partialpage=\box16 | |
| 17 | \origvsize=\dimen19 | |
| 18 | \manindent=\dimen20 | |
| 19 | \smallmanindent=\dimen21 | |
| 20 | \itfam=\fam11 | |
| 21 | \slfam=\fam12 | |
| 22 | \bffam=\fam13 | |
| 23 | \ttfam=\fam14 | |
| 24 | \msbfam=\fam15 | |
| 25 | \ttindent=\dimen22 | |
| 26 | \labelout=\write0 | |
| 27 | \indexout=\write1 | |
| 28 | \secindout=\write2 | |
| 29 | \tocout=\write3 | |
| 30 | \citeout=\write4 | |
| 31 | \ans=\write5 | |
| 32 | \exampleout=\write6 | |
| 33 | \labelin=\read1 | |
| 34 | \indexin=\read2 | |
| 35 | \tocin=\read3 | |
| 36 | \citein=\read4 | |
| 37 | \secno=\count27 | |
| 38 | \subsecno=\count28 | |
| 39 | \exno=\count29 | |
| 40 | \indentno=\count30 | |
| 41 | \chapnum=\count31 | |
| 42 | \ortoks=\toks13 | |
| 43 | \bibindent=\dimen23 | |
| 44 | ) [1{/usr/local/texlive/2016/texmf-var/fonts/map/pdftex/updmap/pdftex.map}] | |
| 45 | \makelabel{etudes:Contents}{{\setbox 0=\hbox {1}\vrule width 0pt height\ht 0}} | |
| 46 | Chapter `Contents' . | |
| 47 | (./manual.toc) [2.1 | |
| 48 | \chapcontents {\tocstrut }{Contents}{2} | |
| 49 | ] (./manual.lab) | |
| 50 | \openout3 = `manual.toc'. | |
| 51 | ||
| 52 | \openout0 = `manual.lab'. | |
| 53 | ||
| 54 | \openout1 = `manual.idx'. | |
| 55 | ||
| 56 | \openout2 = `manual.six'. | |
| 57 | ||
| 58 | \openout4 = `manual.aux'. | |
| 59 | ||
| 60 | (./authors.tex | |
| 61 | Chapter `The authors' . | |
| 62 | ) [3.2] (./grpsupp.tex | |
| 63 | Chapter `Groups' . | |
| 64 | \openout6 = `manual.example-1.tst'. | |
| 65 | ||
| 66 | [4.1] [5.1]) (./nr.tex [6.1] | |
| 67 | Chapter `Nearrings' . | |
| 68 | Reference `meldrum85:NATLWG' undefined. | |
| 69 | Reference `Clay:Nearrings' undefined. | |
| 70 | Reference `Ferrero:Nearrings' undefined. | |
| 71 | Reference `Pilz:Nearrings' undefined. | |
| 72 | Reference `Pilz:Nearrings' undefined. | |
| 73 | \openout6 = `manual.example-2.tst'. | |
| 74 | ||
| 75 | ||
| 76 | Overfull \hbox (0.72127pt too wide) in paragraph at lines 74--81 | |
| 77 | []\tenr Now for en-ter-ing the near-ring mul-ti-pli-ca-tion: We will use the fu | |
| 78 | nc-tion \tentt Nr-Mul-ti-pli-ca-tion-By-Op-er-a-tionTable\tenr .| | |
| 79 | ||
| 80 | \hbox(6.94444+2.22223)x468.0, glue set - 1.0 | |
| 81 | .\hbox(0.0+0.0)x0.0 | |
| 82 | .\tenr N | |
| 83 | .\tenr o | |
| 84 | .\kern-0.27779 | |
| 85 | .\tenr w | |
| 86 | .etc. | |
| 87 | ||
| 88 | [7.2] | |
| 89 | Reference `Waehling:Fastkoerper' undefined. | |
| 90 | Reference `Pilz:Nearrings' undefined. | |
| 91 | [8.2]) (./libnr.tex [9.2] | |
| 92 | Chapter `The nearring library' . | |
| 93 | \openout6 = `manual.example-3.tst'. | |
| 94 | ||
| 95 | [10.3] | |
| 96 | Reference `Pilz:Nearrings' undefined. | |
| 97 | [11.3] | |
| 98 | Reference `Pilz:Nearrings' undefined. | |
| 99 | Reference `Pilz:Nearrings' undefined. | |
| 100 | ||
| 101 | Overfull \hbox (20.3064pt too wide) in paragraph at lines 164--167 | |
| 102 | []\tenr For those who got in-ter-ested in boolean near-rings: many re-sults abo | |
| 103 | ut them have been col-lected in [][][][Pilz:Nearrings][][],| | |
| 104 | ||
| 105 | \hbox(7.5+2.5)x468.0, glue set - 1.0 | |
| 106 | .\hbox(0.0+0.0)x0.0 | |
| 107 | .\tenr F | |
| 108 | .\kern-0.83334 | |
| 109 | .\tenr o | |
| 110 | .\tenr r | |
| 111 | .etc. | |
| 112 | ||
| 113 | ) (./tfms.tex [12.3] | |
| 114 | Chapter `Nearrings of transformations on groups' . | |
| 115 | \openout6 = `manual.example-4.tst'. | |
| 116 | ||
| 117 | [13.4]) (./tfmnr.tex [14.4] | |
| 118 | Chapter `Some interesting nearrings' . | |
| 119 | Reference `meldrum85:NATLWG' undefined. | |
| 120 | \openout6 = `manual.example-5.tst'. | |
| 121 | ||
| 122 | [15.5] [16.5] | |
| 123 | Reference `thomaswood80:GT' undefined. | |
| 124 | Reference `Pilz:Nearrings' undefined. | |
| 125 | [17.5]) (./ideals.tex [18.5] | |
| 126 | Chapter `Ideals, factors, and direct products of nearrings' . | |
| 127 | \openout6 = `manual.example-6.tst'. | |
| 128 | ||
| 129 | [19.6] [20.6]) (./plnr.tex [21.6] | |
| 130 | Chapter `Planar nearrings' . | |
| 131 | Reference `Clay:Nearrings' undefined. | |
| 132 | \openout6 = `manual.example-7.tst'. | |
| 133 | ||
| 134 | [22.7]) (./design.tex [23.7] | |
| 135 | Chapter `Designs' . | |
| 136 | Reference `Clay:Nearrings' undefined. | |
| 137 | \openout6 = `manual.example-8.tst'. | |
| 138 | ||
| 139 | [24.8]) [25.8] | |
| 140 | Chapter `Bibliography' . | |
| 141 | No file manual.bbl. | |
| 142 | [26.9] | |
| 143 | Chapter `Index' . | |
| 144 | No file manual.ind. | |
| 145 | ## | |
| 146 | ## Citations for BibTeX written on manual.aux. | |
| 147 | ## Index entries for makeindex written on manual.idx. | |
| 148 | ## Section index entries written on manual.six. | |
| 149 | ## Label definitions written on manual.lab. | |
| 150 | ## Table of contents written on manual.toc. | |
| 151 | ## Examples written to manual.example-XX.tst. | |
| 152 | ## There were undefined labels or references. | |
| 153 | ## Labels have changed, run again. (Or they were multiply defined.) | |
| 154 | ## | |
| 155 | [27.10] )pdfTeX warning (dest): name{index} has been referenced but does not ex | |
| 156 | ist, replaced by a fixed one | |
| 157 | ||
| 158 | pdfTeX warning (dest): name{citation@thomaswood80:GT} has been referenced but d | |
| 159 | oes not exist, replaced by a fixed one | |
| 160 | ||
| 161 | pdfTeX warning (dest): name{citation@Waehling:Fastkoerper} has been referenced | |
| 162 | but does not exist, replaced by a fixed one | |
| 163 | ||
| 164 | pdfTeX warning (dest): name{citation@Pilz:Nearrings} has been referenced but do | |
| 165 | es not exist, replaced by a fixed one | |
| 166 | ||
| 167 | pdfTeX warning (dest): name{citation@Ferrero:Nearrings} has been referenced but | |
| 168 | does not exist, replaced by a fixed one | |
| 169 | ||
| 170 | pdfTeX warning (dest): name{citation@Clay:Nearrings} has been referenced but do | |
| 171 | es not exist, replaced by a fixed one | |
| 172 | ||
| 173 | pdfTeX warning (dest): name{citation@meldrum85:NATLWG} has been referenced but | |
| 174 | does not exist, replaced by a fixed one | |
| 175 | ||
| 176 | </usr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmbx10.pfb>< | |
| 177 | /usr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmex10.pfb></ | |
| 178 | usr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cminch.pfb></u | |
| 179 | sr/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi10.pfb></us | |
| 180 | r/local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi7.pfb></usr/ | |
| 181 | local/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb></usr/lo | |
| 182 | cal/texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmr5.pfb></usr/local | |
| 183 | /texlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmr7.pfb></usr/local/te | |
| 184 | xlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmss10.pfb></usr/local/tex | |
| 185 | live/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmssdc10.pfb></usr/local/te | |
| 186 | xlive/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy10.pfb></usr/local/tex | |
| 187 | live/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmsy7.pfb></usr/local/texli | |
| 188 | ve/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmti10.pfb></usr/local/texliv | |
| 189 | e/2016/texmf-dist/fonts/type1/public/amsfonts/cm/cmtt10.pfb></usr/local/texlive | |
| 190 | /2016/texmf-dist/fonts/type1/public/amsfonts/symbols/msbm10.pfb> | |
| 191 | Output written on manual.pdf (27 pages, 221291 bytes). | |
| 192 | PDF statistics: | |
| 193 | 326 PDF objects out of 1000 (max. 8388607) | |
| 194 | 279 compressed objects within 3 object streams | |
| 195 | 35 named destinations out of 1000 (max. 500000) | |
| 196 | 233 words of extra memory for PDF output out of 10000 (max. 10000000) | |
| 197 |
| 0 | preamble "" | |
| 1 | postamble "\n" | |
| 2 | group_skip "\n" | |
| 3 | headings_flag 1 | |
| 4 | heading_prefix "\\letter " | |
| 5 | numhead_positive "{}" | |
| 6 | symhead_positive "{}" | |
| 7 | item_0 "\n " | |
| 8 | item_1 "\n \\sub " | |
| 9 | item_01 "\n \\sub " | |
| 10 | item_x1 ", " | |
| 11 | item_2 "\n \\subsub " | |
| 12 | item_12 "\n \\subsub " | |
| 13 | item_x2 ", " | |
| 14 | page_compositor "--" | |
| 15 | line_max 1000 |
Binary diff not shown
| 0 | C grpsupp.tex 1. Groups | |
| 1 | S 1.1. Thomas' and Wood's catalogue of small groups | |
| 2 | S 1.2. Subgroups | |
| 3 | S 1.3. Group endomorphisms | |
| 4 | S 1.4. Finding a set of generators | |
| 5 | C nr.tex 2. Nearrings | |
| 6 | S 2.1. Entering nearrings into the system | |
| 7 | S 2.2. Some simple questions about the nearring | |
| 8 | S 2.3. Entering the nearring with less typing | |
| 9 | C libnr.tex 3. The nearring library | |
| 10 | S 3.1. An application of the nearring library | |
| 11 | S 3.2. Appendix K revisited | |
| 12 | C tfms.tex 4. Nearrings of transformations on groups | |
| 13 | C tfmnr.tex 5. Some interesting nearrings | |
| 14 | S 5.1. Nearrings generated by endomorphisms on a group | |
| 15 | S 5.2. More information than just the size | |
| 16 | S 5.3. Centralizer nearrings | |
| 17 | S 5.4. Finding affine complete groups | |
| 18 | C ideals.tex 6. Ideals, factors, and direct products of nearrings | |
| 19 | S 6.1. Direct products | |
| 20 | S 6.2. Ideals and factors | |
| 21 | C plnr.tex 7. Planar nearrings | |
| 22 | C design.tex 8. Designs | |
| 23 | S 8.1. Designs from planar nearrings | |
| 24 | S 8.2. Information on designs |
| 0 | \chapcontents {\tocstrut }{The authors}{3} | |
| 1 | \chapcontents {1}{Groups}{4} | |
| 2 | \seccontents {1.1}{Thomas' and Wood's catalogue of small groups} {4} | |
| 3 | \seccontents {1.2}{Subgroups} {5} | |
| 4 | \seccontents {1.3}{Group endomorphisms} {5} | |
| 5 | \seccontents {1.4}{Finding a set of generators} {6} | |
| 6 | \chapcontents {2}{Nearrings}{7} | |
| 7 | \seccontents {2.1}{Entering nearrings into the system} {7} | |
| 8 | \seccontents {2.2}{Some simple questions about the nearring} {8} | |
| 9 | \seccontents {2.3}{Entering the nearring with less typing} {9} | |
| 10 | \chapcontents {3}{The nearring library}{10} | |
| 11 | \seccontents {3.1}{An application of the nearring library} {10} | |
| 12 | \seccontents {3.2}{Appendix K revisited} {11} | |
| 13 | \chapcontents {4}{Nearrings of transformations on groups}{13} | |
| 14 | \chapcontents {5}{Some interesting nearrings}{15} | |
| 15 | \seccontents {5.1}{Nearrings generated by endomorphisms on a group} {15} | |
| 16 | \seccontents {5.2}{More information than just the size} {16} | |
| 17 | \seccontents {5.3}{Centralizer nearrings} {17} | |
| 18 | \seccontents {5.4}{Finding affine complete groups} {18} | |
| 19 | \chapcontents {6}{Ideals, factors, and direct products of nearrings}{19} | |
| 20 | \seccontents {6.1}{Direct products} {19} | |
| 21 | \seccontents {6.2}{Ideals and factors} {20} | |
| 22 | \chapcontents {7}{Planar nearrings}{22} | |
| 23 | \chapcontents {8}{Designs}{24} | |
| 24 | \seccontents {8.1}{Designs from planar nearrings} {24} | |
| 25 | \seccontents {8.2}{Information on designs} {25} | |
| 26 | \chapcontents {}{Bibliography}{26} |
| 0 | <html><head><title>[SONATA] 1 Supportive functions for groups</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>1 Supportive functions for groups</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP001.htm#SECT001">Predefined groups</a> | |
| 8 | <li> <A HREF="CHAP001.htm#SECT002">Operation tables for groups</a> | |
| 9 | <li> <A HREF="CHAP001.htm#SECT003">Group endomorphisms</a> | |
| 10 | <li> <A HREF="CHAP001.htm#SECT004">Group automorphisms</a> | |
| 11 | <li> <A HREF="CHAP001.htm#SECT005">Inner automorphisms of a group</a> | |
| 12 | <li> <A HREF="CHAP001.htm#SECT006">Isomorphic groups</a> | |
| 13 | <li> <A HREF="CHAP001.htm#SECT007">Subgroups of a group</a> | |
| 14 | <li> <A HREF="CHAP001.htm#SECT008">Normal subgroups generated by a single element</a> | |
| 15 | <li> <A HREF="CHAP001.htm#SECT009">Invariant subgroups</a> | |
| 16 | <li> <A HREF="CHAP001.htm#SECT010">Coset representatives</a> | |
| 17 | <li> <A HREF="CHAP001.htm#SECT011">Scott length</a> | |
| 18 | <li> <A HREF="CHAP001.htm#SECT012">Other useful functions for groups</a> | |
| 19 | </ol><p> | |
| 20 | <p> | |
| 21 | In order to support nearring calculations, a few functions for groups had to | |
| 22 | be added to the standard <font face="Gill Sans,Helvetica,Arial">GAP</font> group library functions. | |
| 23 | <p> | |
| 24 | The functions described here can be found in the source files | |
| 25 | <code>grpend.g?</code> and <code>grpsupp.g?</code> | |
| 26 | <p> | |
| 27 | <p> | |
| 28 | <h2><a name="SECT001">1.1 Predefined groups</a></h2> | |
| 29 | <p><p> | |
| 30 | All groups of order 2 to 32 are predefined. They can be accessed | |
| 31 | by variables of the kind <code>GTW</code><var>o</var><code>_</code><var>n</var><code></code> where <var>o</var> defines the order | |
| 32 | of the group and <var>n</var> the number of the group of order <var>o</var> as they | |
| 33 | appear in <a href="biblio.htm#thomaswood80:GT"><[>thomaswood80:GT</cite></a>] . For example, <code>GTW16_6</code> defines the | |
| 34 | group of Thomas -- Wood type 16/6, which is actually <i>D</i><sub>4</sub> ×<i>C</i><sub>2</sub>. | |
| 35 | <p> | |
| 36 | Alternatively, these groups can be accessed via the function | |
| 37 | <p> | |
| 38 | <a name = "SSEC001.1"></a> | |
| 39 | <li><code>TWGroup( </code><var>o</var><code>, </code><var>n</var><code> )</code> | |
| 40 | <p> | |
| 41 | with <var>o</var> and <var>n</var> as above. In addition, all these groups are stored in the | |
| 42 | list ttGroupList. | |
| 43 | <p> | |
| 44 | Conversely, for any group <var>G</var> of order at most 32, | |
| 45 | <p> | |
| 46 | <a name = "SSEC001.2"></a> | |
| 47 | <li><code>IdTWGroup( </code><var>G</var><code> )</code> | |
| 48 | <p> | |
| 49 | returns a pair <code>[</code><var>o</var><code>,</code><var>n</var><code>]</code>, meaning that <var>G</var> is isomorphic to the group | |
| 50 | <i>o</i>/<i>n</i>. | |
| 51 | <p> | |
| 52 | <pre> | |
| 53 | gap> G := GTW6_2; | |
| 54 | 6/2 | |
| 55 | gap> H := TWGroup( 4, 2 ); | |
| 56 | 4/2 | |
| 57 | gap> D := DirectProduct( G, H ); | |
| 58 | Group([ (1,2), (1,2,3), (4,5), (6,7) ]) | |
| 59 | gap> IdTWGroup( D ); | |
| 60 | [ 24, 4 ] | |
| 61 | gap> GroupList; | |
| 62 | [ 2/1, 3/1, 4/1, 4/2, 5/1, 6/1, 6/2, 7/1, 8/1, 8/2, 8/3, 8/4, 8/5, | |
| 63 | 9/1, 9/2, 10/1, 10/2, 11/1, 12/1, 12/2, 12/3, 12/4, 12/5, 13/1, | |
| 64 | 14/1, 14/2, 15/1, 16/1, 16/2, 16/3, 16/4, 16/5, 16/6, 16/7, 16/8, | |
| 65 | 16/9, 16/10, 16/11, 16/12, 16/13, 16/14, 17/1, 18/1, 18/2, 18/3, | |
| 66 | 18/4, 18/5, 19/1, 20/1, 20/2, 20/3, 20/4, 20/5, 21/1, 21/2, 22/1, | |
| 67 | 22/2, 23/1, 24/1, 24/2, 24/3, 24/4, 24/5, 24/6, 24/7, 24/8, 24/9, | |
| 68 | 24/10, 24/11, 24/12, 24/13, 24/14, 24/15, 25/1, 25/2, 26/1, 26/2, | |
| 69 | 27/1, 27/2, 27/3, 27/4, 27/5, 28/1, 28/2, 28/3, 28/4, 29/1, 30/1, | |
| 70 | 30/2, 30/3, 30/4, 31/1, 32/1, 32/2, 32/3, 32/4, 32/5, 32/6, 32/7, | |
| 71 | 32/8, 32/9, 32/10, 32/11, 32/12, 32/13, 32/14, 32/15, 32/16, 32/17, | |
| 72 | 32/18, 32/19, 32/20, 32/21, 32/22, 32/23, 32/24, 32/25, 32/26, | |
| 73 | 32/27, 32/28, 32/29, 32/30, 32/31, 32/32, 32/33, 32/34, 32/35, | |
| 74 | 32/36, 32/37, 32/38, 32/39, 32/40, 32/41, 32/42, 32/43, 32/44, | |
| 75 | 32/45, 32/46, 32/47, 32/48, 32/49, 32/50, 32/51 ] | |
| 76 | </pre> | |
| 77 | <p> | |
| 78 | <p> | |
| 79 | <h2><a name="SECT002">1.2 Operation tables for groups</a></h2> | |
| 80 | <p><p> | |
| 81 | <a name = "SSEC002.1"></a> | |
| 82 | <li><code>PrintTable( </code><var>G</var><code> )</code> | |
| 83 | <p> | |
| 84 | <code>PrintTable</code> prints the Cayley table of the group <var>G</var>. | |
| 85 | <p> | |
| 86 | <pre> | |
| 87 | gap> G := GTW4_2; | |
| 88 | 4/2 | |
| 89 | gap> PrintTable( G ); | |
| 90 | Let: | |
| 91 | g0 := () | |
| 92 | g1 := (3,4) | |
| 93 | g2 := (1,2) | |
| 94 | g3 := (1,2)(3,4) | |
| 95 | ||
| 96 | * | g0 g1 g2 g3 | |
| 97 | ------------------ | |
| 98 | g0 | g0 g1 g2 g3 | |
| 99 | g1 | g1 g0 g3 g2 | |
| 100 | g2 | g2 g3 g0 g1 | |
| 101 | g3 | g3 g2 g1 g0 | |
| 102 | ||
| 103 | </pre> | |
| 104 | <p> | |
| 105 | Sometimes different symbols for the elements in the would make the table | |
| 106 | look nicer. For the group 4/2 (<b>Z</b><sub>2</sub> ×<b>Z</b><sub>2</sub>) one could choose | |
| 107 | the canonical form as pairs of zeros and ones. | |
| 108 | <p> | |
| 109 | <pre> | |
| 110 | gap> G := GTW4_2; | |
| 111 | 4/2 | |
| 112 | gap> SetSymbols( G, ["(0,0)","(1,0)","(0,1)","(1,1)"] ); | |
| 113 | gap> PrintTable( G ); | |
| 114 | Let: | |
| 115 | (0,0) := () | |
| 116 | (1,0) := (3,4) | |
| 117 | (0,1) := (1,2) | |
| 118 | (1,1) := (1,2)(3,4) | |
| 119 | ||
| 120 | * | (0,0) (1,0) (0,1) (1,1) | |
| 121 | ----------------------------------- | |
| 122 | (0,0) | (0,0) (1,0) (0,1) (1,1) | |
| 123 | (1,0) | (1,0) (0,0) (1,1) (0,1) | |
| 124 | (0,1) | (0,1) (1,1) (0,0) (1,0) | |
| 125 | (1,1) | (1,1) (0,1) (1,0) (0,0) | |
| 126 | </pre> | |
| 127 | <p> | |
| 128 | <p> | |
| 129 | <h2><a name="SECT003">1.3 Group endomorphisms</a></h2> | |
| 130 | <p><p> | |
| 131 | <a name = "SSEC003.1"></a> | |
| 132 | <li><code>Endomorphisms( </code><var>G</var><code> )</code> | |
| 133 | <p> | |
| 134 | <code>Endomorphisms</code> computes all the endomorphisms of the group <var>G</var>. | |
| 135 | This function is most essential for computing the nearrings on a group. | |
| 136 | The endomorphisms are returned as a list of group homomorphisms. So all | |
| 137 | functions for mappings and homomorphisms are applicable. | |
| 138 | <p> | |
| 139 | <pre> | |
| 140 | gap> G := TWGroup( 4, 2 ); | |
| 141 | 4/2 | |
| 142 | gap> Endomorphisms( G ); | |
| 143 | [ [ (1,2), (3,4) ] -> [ (), () ], [ (1,2), (3,4) ] -> [ (), (1,2) ], | |
| 144 | [ (1,2), (3,4) ] -> [ (), (3,4) ], [ (1,2), (3,4) ] -> [ (), (1,2)(3,4) ], | |
| 145 | [ (1,2), (3,4) ] -> [ (1,2), () ], [ (1,2), (3,4) ] -> [ (3,4), () ], | |
| 146 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), () ], [ (1,2), (3,4) ] -> [ (1,2), (1,2) ] | |
| 147 | , [ (1,2), (3,4) ] -> [ (3,4), (3,4) ], | |
| 148 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), (1,2)(3,4) ], | |
| 149 | [ (1,2), (3,4) ] -> [ (1,2), (3,4) ], | |
| 150 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), (3,4) ], | |
| 151 | [ (1,2), (3,4) ] -> [ (3,4), (1,2) ], | |
| 152 | [ (1,2), (3,4) ] -> [ (1,2)(3,4), (1,2) ], | |
| 153 | [ (1,2), (3,4) ] -> [ (3,4), (1,2)(3,4) ], | |
| 154 | [ (1,2), (3,4) ] -> [ (1,2), (1,2)(3,4) ] ] | |
| 155 | </pre> | |
| 156 | <p> | |
| 157 | <p> | |
| 158 | <h2><a name="SECT004">1.4 Group automorphisms</a></h2> | |
| 159 | <p><p> | |
| 160 | <a name = "SSEC004.1"></a> | |
| 161 | <li><code>Automorphisms( </code><var>G</var><code> )</code> | |
| 162 | <p> | |
| 163 | <code>Automorphisms</code> computes all the automorphisms of the group <var>G</var>. | |
| 164 | The automorphisms are returned as a list of group homomorphisms. So all | |
| 165 | functions for mappings and homomorphisms are applicable. | |
| 166 | <p> | |
| 167 | <pre> | |
| 168 | gap> Automorphisms( GTW4_2 ); | |
| 169 | [ IdentityMapping( 4/2 ), [ (1,2), (3,4) ] -> [ (1,2)(3,4), (3,4) ], | |
| 170 | [ (1,2), (3,4) ] -> [ (3,4), (1,2) ], | |
| 171 | [ (3,4), (1,2) ] -> [ (1,2), (1,2)(3,4) ], | |
| 172 | [ (3,4), (1,2) ] -> [ (1,2)(3,4), (3,4) ], | |
| 173 | [ (3,4), (1,2) ] -> [ (1,2)(3,4), (1,2) ] ] | |
| 174 | </pre> | |
| 175 | <p> | |
| 176 | <p> | |
| 177 | <h2><a name="SECT005">1.5 Inner automorphisms of a group</a></h2> | |
| 178 | <p><p> | |
| 179 | <a name = "SSEC005.1"></a> | |
| 180 | <li><code>InnerAutomorphisms( </code><var>G</var><code> )</code> | |
| 181 | <p> | |
| 182 | <code>InnerAutomorphisms</code> computes all the inner automorphisms of the group | |
| 183 | <var>G</var>. | |
| 184 | The inner automorphisms are returned as a list of group homomorphisms. So all | |
| 185 | functions for mappings and homomorphisms are applicable. | |
| 186 | <p> | |
| 187 | <pre> | |
| 188 | gap> InnerAutomorphisms( AlternatingGroup( 4 ) ); | |
| 189 | [ ^(), ^(2,3,4), ^(2,4,3), ^(1,2)(3,4), ^(1,2,3), ^(1,2,4), | |
| 190 | ^(1,3,2), ^(1,3,4), ^(1,3)(2,4), ^(1,4,2), ^(1,4,3), ^(1,4)(2,3) ] | |
| 191 | </pre> | |
| 192 | <p> | |
| 193 | <p> | |
| 194 | <h2><a name="SECT006">1.6 Isomorphic groups</a></h2> | |
| 195 | <p><p> | |
| 196 | <a name = "SSEC006.1"></a> | |
| 197 | <li><code>IsIsomorphicGroup( </code><var>G</var><code>, </code><var>H</var><code> )</code> | |
| 198 | <p> | |
| 199 | <code>IsIsomorphicGroup</code> determines if the groups <var>G</var> and <var>H</var> are | |
| 200 | isomorphic. If they are isomorphic, an isomorphism between these two groups | |
| 201 | can be found with <code>IsomorphismGroups</code>. | |
| 202 | <p> | |
| 203 | <pre> | |
| 204 | gap> IsIsomorphicGroup( SymmetricGroup( 4 ), GTW24_12 ); | |
| 205 | true | |
| 206 | </pre> | |
| 207 | <p> | |
| 208 | <p> | |
| 209 | <h2><a name="SECT007">1.7 Subgroups of a group</a></h2> | |
| 210 | <p><p> | |
| 211 | <a name = "SSEC007.1"></a> | |
| 212 | <li><code>Subgroups( </code><var>G</var><code> )</code> | |
| 213 | <p> | |
| 214 | <code>Subgroups</code> returns a list of all subgroups of the group <var>G</var>, if there | |
| 215 | are only finitely many subgroups. | |
| 216 | <p> | |
| 217 | <pre> | |
| 218 | gap> Subgroups( TWGroup( 8, 4 ) ); | |
| 219 | [ Group(()), Group([ (1,3)(2,4) ]), Group([ (2,4) ]), Group([ (1,3) ]), | |
| 220 | Group([ (1,2)(3,4) ]), Group([ (1,4)(2,3) ]), Group([ (1,3)(2,4), (2,4) ]), | |
| 221 | Group([ (1,3)(2,4), (1,2,3,4) ]), Group([ (1,3)(2,4), (1,2)(3,4) ]), | |
| 222 | Group([ (1,3)(2,4), (2,4), (1,2,3,4) ]) ] | |
| 223 | </pre> | |
| 224 | <p> | |
| 225 | <p> | |
| 226 | <h2><a name="SECT008">1.8 Normal subgroups generated by a single element</a></h2> | |
| 227 | <p><p> | |
| 228 | <a name = "SSEC008.1"></a> | |
| 229 | <li><code>OneGeneratedNormalSubgroups( </code><var>G</var><code> )</code> | |
| 230 | <p> | |
| 231 | <code>OneGeneratedSubgroups</code> returns a list of all proper, non-trivial normal | |
| 232 | subgroups of the group <var>G</var> which are generated by one element. | |
| 233 | <code>OneGeneratedSubgroups</code> is a synonym for <code>GeneratorsOfCongruenceLattice</code>. | |
| 234 | <p> | |
| 235 | <pre> | |
| 236 | gap> OneGeneratedNormalSubgroups( AlternatingGroup(4) ); | |
| 237 | [ Group([ (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ]) ] | |
| 238 | </pre> | |
| 239 | <p> | |
| 240 | <p> | |
| 241 | <h2><a name="SECT009">1.9 Invariant subgroups</a></h2> | |
| 242 | <p><p> | |
| 243 | <a name = "SSEC009.1"></a> | |
| 244 | <li><code>IsInvariantUnderMaps( </code><var>G</var><code>, </code><var>U</var><code>, </code><var>maps</var><code> )</code> | |
| 245 | <p> | |
| 246 | For a list of mappings, <var>maps</var> on the group <var>G</var> and | |
| 247 | a subgroup <var>U</var> of <var>G</var>, <code>IsInvariantUnderMaps</code> returns the truth | |
| 248 | value of ``<var>U</var> is invariant under all mappings in <var>maps</var>''. In the following | |
| 249 | example this function is used to compute all fully invariant subgroups of | |
| 250 | the dihedral group of order 12. | |
| 251 | <p> | |
| 252 | <pre> | |
| 253 | gap> D12 := DihedralGroup( 12 ); | |
| 254 | <pc group of size 12 with 3 generators> | |
| 255 | gap> s := Subgroups( D12 ); | |
| 256 | [ Group([ ]), Group([ f1 ]), Group([ f1*f3^2 ]), Group([ f1*f3 ]), | |
| 257 | Group([ f2*f3 ]), Group([ f1*f2 ]), Group([ f1*f2*f3^2 ]), | |
| 258 | Group([ f1*f2*f3 ]), Group([ f3 ]), Group([ f1, f2*f3 ]), | |
| 259 | Group([ f1*f3^2, f2*f3 ]), Group([ f1*f3, f2*f3 ]), | |
| 260 | Group([ f3, f1 ]), Group([ f3, f2 ]), Group([ f3, f1*f2 ]), | |
| 261 | Group([ f3, f1, f2 ]) ] | |
| 262 | gap> e := Endomorphisms( D12 );; | |
| 263 | gap> f := Filtered( s, sg -> IsInvariantUnderMaps( D12, sg, e ) ); | |
| 264 | [ Group([ ]), Group([ f3 ]), Group([ f3, f1, f2 ]) ] | |
| 265 | </pre> | |
| 266 | <p> | |
| 267 | <a name = "SSEC009.2"></a> | |
| 268 | <li><code>IsCharacteristicSubgroup( </code><var>G</var><code>, </code><var>U</var><code> )</code> | |
| 269 | <p> | |
| 270 | A subgroup <var>U</var> of the group <var>G</var> is <strong>characteristic</strong> if it is invariant under | |
| 271 | all automorphisms on <var>G</var>. For a subgroup <var>U</var> of the group <var>G</var>, | |
| 272 | <code>IsCharacteristicSubgroup</code> returns the truth value of ``<var>U</var> is a characteristic | |
| 273 | subgroup of <var>G</var>''. If the group <var>U</var> is defined as the subgroup of a group | |
| 274 | <var>G</var> then the function call | |
| 275 | <p> | |
| 276 | <a name = "SSEC009.3"></a> | |
| 277 | <li><code>IsCharacteristicInParent( </code><var>U</var><code> )</code> | |
| 278 | <p> | |
| 279 | has the same result. | |
| 280 | <p> | |
| 281 | <pre> | |
| 282 | gap> IsCharacteristicInParent( Centre( GTW16_11 ) ); | |
| 283 | true | |
| 284 | </pre> | |
| 285 | <p> | |
| 286 | <a name = "SSEC009.4"></a> | |
| 287 | <li><code>IsFullinvariant( </code><var>G</var><code>, </code><var>U</var><code> )</code> | |
| 288 | <p> | |
| 289 | A subgroup <var>U</var> of the group <var>G</var> is <strong>fully invariant</strong> if it is invariant under | |
| 290 | all endomorphisms on <var>G</var>. | |
| 291 | For a subgroup <var>U</var> of the group <var>G</var>, <code>IsFullinvariant</code> returns the | |
| 292 | truth value of ``<var>U</var> is a fully invariant subgroup of <var>G</var>''. | |
| 293 | <p> | |
| 294 | <pre> | |
| 295 | gap> G := GTW6_2; | |
| 296 | 6/2 | |
| 297 | gap> S := Subgroup( G, [(1,2)] ); | |
| 298 | Group([ (1,2) ]) | |
| 299 | gap> IsFullinvariant( G, S ); | |
| 300 | false | |
| 301 | </pre> | |
| 302 | <p> | |
| 303 | If the group <var>U</var> is defined as the subgroup of a group <var>G</var> then the function | |
| 304 | call | |
| 305 | <p> | |
| 306 | <a name = "SSEC009.5"></a> | |
| 307 | <li><code>IsFullinvariantInParent( </code><var>U</var><code> )</code> | |
| 308 | <p> | |
| 309 | has the same result. | |
| 310 | <p> | |
| 311 | <pre> | |
| 312 | gap> IsFullinvariantInParent( Centre( GTW16_11 ) ); | |
| 313 | true | |
| 314 | </pre> | |
| 315 | <p> | |
| 316 | <p> | |
| 317 | <h2><a name="SECT010">1.10 Coset representatives</a></h2> | |
| 318 | <p><p> | |
| 319 | <a name = "SSEC010.1"></a> | |
| 320 | <li><code>RepresentativesModNormalSubgroup( </code><var>G</var><code>, </code><var>N</var><code> )</code> | |
| 321 | <p> | |
| 322 | If <var>G</var> is a group and <var>N</var> is a normal subgroup of <var>G</var> then the function | |
| 323 | <code>RepresentativesModNormalSubgroup</code> returns a set of representatives for | |
| 324 | the congruence classes modulo the normal subgroup <var>N</var>, i.e. a set of elements | |
| 325 | of <var>G</var> with exactly one element from each cogruence class modulo <var>N</var>. | |
| 326 | <p> | |
| 327 | <pre> | |
| 328 | gap> G := DihedralGroup( 16 ); | |
| 329 | <pc group of size 16 with 4 generators> | |
| 330 | gap> C := Centre( G ); | |
| 331 | Group([ f4 ]) | |
| 332 | gap> RepresentativesModNormalSubgroup( G, C ); | |
| 333 | [ <identity> of ..., f1, f2, f3, f2*f3, f1*f2*f4, f1*f3*f4, | |
| 334 | f1*f2*f3*f4 ] | |
| 335 | </pre> | |
| 336 | <p> | |
| 337 | <a name = "SSEC010.2"></a> | |
| 338 | <li><code>NontrivialRepresentativesModNormalSubgroup( </code><var>G</var><code>, </code><var>N</var><code> )</code> | |
| 339 | <p> | |
| 340 | This function behaves as <code>RepresentativesModNormalSubgroup</code> but it excludes | |
| 341 | the representative for the congruence class which contains the neutral element | |
| 342 | of the group. | |
| 343 | <p> | |
| 344 | <pre> | |
| 345 | gap> G := DihedralGroup( 16 ); | |
| 346 | <pc group of size 16 with 4 generators> | |
| 347 | gap> C := Centre( G ); | |
| 348 | Group([ f4 ]) | |
| 349 | gap> NontrivialRepresentativesModNormalSubgroup( G, C ); | |
| 350 | [ f1, f2, f3, f2*f3, f1*f2*f4, f1*f3*f4, f1*f2*f3*f4 ] | |
| 351 | </pre> | |
| 352 | <p> | |
| 353 | <p> | |
| 354 | <h2><a name="SECT011">1.11 Scott length</a></h2> | |
| 355 | <p><p> | |
| 356 | <a name = "SSEC011.1"></a> | |
| 357 | <li><code>ScottLength( </code><var>G</var><code> )</code> | |
| 358 | <p> | |
| 359 | The function <code>ScottLength</code> retuns the Scott-length of the group <var>G</var>. | |
| 360 | For a definition of the Scott-length of a group and an idea for an | |
| 361 | algorithm for the general case see <a href="biblio.htm#scott69:TAOPMOAGATSOCPPGI"><[>scott69:TAOPMOAGATSOCPPGI</cite></a>]. | |
| 362 | In the case of a class 2 nilpotent finite group <var>G</var> a faster algorithm | |
| 363 | described in <a href="biblio.htm#ecker98:OTNOPFONGOC2"><[>ecker98:OTNOPFONGOC2</cite></a>] is used. | |
| 364 | <p> | |
| 365 | <pre> | |
| 366 | gap> ScottLength( GTW6_2 ); | |
| 367 | 2 | |
| 368 | gap> ScottLength( GTW16_11 ); | |
| 369 | 4 | |
| 370 | </pre> | |
| 371 | <p> | |
| 372 | <p> | |
| 373 | <h2><a name="SECT012">1.12 Other useful functions for groups</a></h2> | |
| 374 | <p><p> | |
| 375 | <a name = "SSEC012.1"></a> | |
| 376 | <li><code>AsPermGroup( </code><var>G</var><code> )</code> | |
| 377 | <p> | |
| 378 | For a group <var>G</var>, <code>AsPermGroup</code> returns a permutation group that is isomorphic | |
| 379 | to <var>G</var>. In the case of a permutation group this is the group itself. | |
| 380 | <p> | |
| 381 | <pre> | |
| 382 | gap> D24 := DihedralGroup( 24 ); | |
| 383 | <pc group of size 24 with 4 generators> | |
| 384 | gap> D24p := AsPermGroup( D24 ); | |
| 385 | <permutation group of size 24 with 4 generators> | |
| 386 | gap> IsomorphismGroups( D24, D24p ); | |
| 387 | [ f1, f2, f3, f4 ] -> | |
| 388 | [ (1,17)(2,16)(3,18)(4,14)(5,13)(6,15)(7,20)(8,19)(9,21)(10,22)(11,24)(12,23), | |
| 389 | (1,11,4,9,2,12,5,7,3,10,6,8)(13,23,16,21,14,24,17,19,15,22,18,20), | |
| 390 | (1,4,2,5,3,6)(7,10,8,11,9,12)(13,16,14,17,15,18)(19,22,20,23,21,24), | |
| 391 | (1,2,3)(4,5,6)(7,8,9)(10,11,12)(13,14,15)(16,17,18)(19,20,21)(22,23,24) ] | |
| 392 | gap> C12 := CyclicGroup( 12 ); | |
| 393 | <pc group of size 12 with 3 generators> | |
| 394 | gap> AsPermGroup( C12 ); | |
| 395 | Group([ ( 1, 7, 4,10, 2, 8, 5,11, 3, 9, 6,12), | |
| 396 | ( 1, 4, 2, 5, 3, 6)( 7,10, 8,11, 9,12), | |
| 397 | ( 1, 2, 3)( 4, 5, 6)( 7, 8, 9)(10,11,12) ]) | |
| 398 | </pre> | |
| 399 | <p> | |
| 400 | <p> | |
| 401 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 402 | <P> | |
| 403 | <address>SONATA manual<br>October 2018 | |
| 404 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 2 Nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>2 Nearrings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP002.htm#SECT001">Defining a nearring multiplication</a> | |
| 8 | <li> <A HREF="CHAP002.htm#SECT002">Construction of nearrings</a> | |
| 9 | <li> <A HREF="CHAP002.htm#SECT003">Direct products of nearrings</a> | |
| 10 | <li> <A HREF="CHAP002.htm#SECT004">Operation tables for nearrings</a> | |
| 11 | <li> <A HREF="CHAP002.htm#SECT005">Modified symbols for the operation tables</a> | |
| 12 | <li> <A HREF="CHAP002.htm#SECT006">Accessing nearring elements</a> | |
| 13 | <li> <A HREF="CHAP002.htm#SECT007">Nearring elements</a> | |
| 14 | <li> <A HREF="CHAP002.htm#SECT008">Random nearring elements</a> | |
| 15 | <li> <A HREF="CHAP002.htm#SECT009">Nearring generators</a> | |
| 16 | <li> <A HREF="CHAP002.htm#SECT010">Size of a nearring</a> | |
| 17 | <li> <A HREF="CHAP002.htm#SECT011">The additive group of a nearring</a> | |
| 18 | <li> <A HREF="CHAP002.htm#SECT012">Nearring endomorphisms</a> | |
| 19 | <li> <A HREF="CHAP002.htm#SECT013">Nearring automorphisms</a> | |
| 20 | <li> <A HREF="CHAP002.htm#SECT014">Isomorphic nearrings</a> | |
| 21 | <li> <A HREF="CHAP002.htm#SECT015">Subnearrings</a> | |
| 22 | <li> <A HREF="CHAP002.htm#SECT016">Invariant subnearrings</a> | |
| 23 | <li> <A HREF="CHAP002.htm#SECT017">Constructing subnearrings</a> | |
| 24 | <li> <A HREF="CHAP002.htm#SECT018">Intersection of nearrings</a> | |
| 25 | <li> <A HREF="CHAP002.htm#SECT019">Identity of a nearring</a> | |
| 26 | <li> <A HREF="CHAP002.htm#SECT020">Units of a nearring</a> | |
| 27 | <li> <A HREF="CHAP002.htm#SECT021">Distributivity in a nearring</a> | |
| 28 | <li> <A HREF="CHAP002.htm#SECT022">Elements of a nearring with special properties</a> | |
| 29 | <li> <A HREF="CHAP002.htm#SECT023">Special properties of a nearring</a> | |
| 30 | </ol><p> | |
| 31 | <p> | |
| 32 | A <strong>(left) nearring</strong> is a nonempty set <i>N</i> together with two binary | |
| 33 | operations on <i>N</i>, + and · s.t. (<i>N</i>,+) is a group, (<i>N</i>,·) is | |
| 34 | a semigroup, and · is left distributive over +, i.e. | |
| 35 | <font face="symbol">"</font><i>n</i><sub>1</sub>,<i>n</i><sub>2</sub>,<i>n</i><sub>3</sub> <font face="symbol">Î</font> <i>N</i>: <i>n</i><sub>1</sub>·(<i>n</i><sub>2</sub>+<i>n</i><sub>3</sub>) = <i>n</i><sub>1</sub>·<i>n</i><sub>2</sub> + <i>n</i><sub>1</sub>·<i>n</i><sub>3</sub>. | |
| 36 | <p> | |
| 37 | For more information we suggest <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>], | |
| 38 | <a href="biblio.htm#meldrum85:NATLWG"><[>meldrum85:NATLWG</cite></a>], and <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>]. | |
| 39 | <p> | |
| 40 | The functions described in this section can be found in the source files | |
| 41 | <code>nr.g?</code> and <code>nrconstr.g?</code>. | |
| 42 | <p> | |
| 43 | <p> | |
| 44 | <h2><a name="SECT001">2.1 Defining a nearring multiplication</a></h2> | |
| 45 | <p><p> | |
| 46 | <a name = "SSEC001.1"></a> | |
| 47 | <li><code>IsNearRingMultiplication( </code><var>G</var><code>, </code><var>mul</var><code>, [</code><var>lcs</var><code>] )</code> | |
| 48 | <p> | |
| 49 | The arguments of the function <code>IsNrMultiplication</code> are a | |
| 50 | group <var>G</var>, a <font face="Gill Sans,Helvetica,Arial">GAP</font>-function <var>mul</var> which has two arguments <code>x</code> and <code>y</code> which | |
| 51 | must both be elements of the group <var>G</var> and returns an element <code>z</code> of <var>G</var> s.t. | |
| 52 | <var>mul</var> defines a binary operation on <em>G</em>. As an optional third parameter | |
| 53 | <code>IsNrMultiplication</code> accepts a list of control strings <var>lcs</var>. | |
| 54 | <p> | |
| 55 | <code>IsNearRingMultiplication</code> returns <code>true</code> (<code>false</code>) if <var>mul</var> is (is not) a nearring | |
| 56 | multiplication on <var>G</var> i.e. it checks whether it is well-defined, associative | |
| 57 | and left distributive over the group operation of <var>G</var>. The list <var>lcs</var> may | |
| 58 | contain one or more of the strings <code> "closed" </code>, <code> "ass" </code> and <code> "rdistr" </code> | |
| 59 | in which case the according property is not tested. In this case it is | |
| 60 | assumed that the user has checked it. This feature should only be used in cases | |
| 61 | where it would take too long to check certain laws element by element and the | |
| 62 | user is absolutely sure about the correctness. | |
| 63 | <p> | |
| 64 | <pre> | |
| 65 | gap> G := TWGroup( 24, 6 ); | |
| 66 | 24/6 | |
| 67 | gap> mul_l := function ( x, y ) return y; end; | |
| 68 | function ( x, y ) ... end | |
| 69 | gap> IsNearRingMultiplication( G, mul_l ); | |
| 70 | true | |
| 71 | gap> mul_r := function ( x, y ) return x; end; | |
| 72 | function ( x, y ) ... end | |
| 73 | gap> IsNearRingMultiplication( G, mul_r ); | |
| 74 | #I specified multiplication is not left distributive. | |
| 75 | false | |
| 76 | gap> IsNearRingMultiplication( G, mul_r, ["closed","ldistr"] ); | |
| 77 | true | |
| 78 | </pre> | |
| 79 | <p> | |
| 80 | <a name = "SSEC001.2"></a> | |
| 81 | <li><code>NearRingMultiplicationByOperationTable( </code><var>G</var><code>, </code><var>table</var><code>, </code><var>elmlist</var><code> )</code> | |
| 82 | <p> | |
| 83 | The function <code>NearRingMultiplicationByOperationTable</code> returns the nearring | |
| 84 | multiplication on the group <var>G</var> which is defined by the multiplication table | |
| 85 | <var>table</var>. Rather than group elements the entries of <var>table</var> are the positions | |
| 86 | of the group element in the list <var>elmlist</var> (the first element in | |
| 87 | <var>elmlist</var> is 1, the second is 2, a.s.o.). Usually the neutral element of the | |
| 88 | group will be the first. | |
| 89 | <p> | |
| 90 | <code>IsNearRingMultiplication</code> can be used to check whether the resulting multiplication | |
| 91 | is indeed a nearring multiplication on <var>G</var>. | |
| 92 | <p> | |
| 93 | <pre> | |
| 94 | gap> G := CyclicGroup( 4 ); | |
| 95 | <pc group of size 4 with 2 generators> | |
| 96 | gap> GeneratorsOfGroup( G ); | |
| 97 | [ f1, f2 ] | |
| 98 | gap> a := last[1]; | |
| 99 | f1 | |
| 100 | gap> Order( a ); | |
| 101 | 4 | |
| 102 | gap> # a generates G indeed | |
| 103 | gap> elmlist := List( [0..3], x -> a^x ); | |
| 104 | [ <identity> of ..., f1, f2, f1*f2 ] | |
| 105 | gap> # Let: 1 := identity of ..., 2 := f1, 3 := f2, 4 := f1*f2 | |
| 106 | gap> # Consider the following multiplication table on G: | |
| 107 | gap> OT := [[1, 1, 1, 1], | |
| 108 | > [1, 4, 3, 2], | |
| 109 | > [1, 1, 1, 1], | |
| 110 | > [1, 2, 3, 4]];; | |
| 111 | gap> mul := NearRingMultiplicationByOperationTable( G, OT, elmlist ); | |
| 112 | function ( x, y ) ... end | |
| 113 | gap> IsNearRingMultiplication( G, mul ); | |
| 114 | true | |
| 115 | </pre> | |
| 116 | <p> | |
| 117 | <p> | |
| 118 | <h2><a name="SECT002">2.2 Construction of nearrings</a></h2> | |
| 119 | <p><p> | |
| 120 | <a name = "SSEC002.1"></a> | |
| 121 | <li><code>ExplicitMultiplicationNearRing( </code><var>G</var><code>, </code><var>mul</var><code> )</code> | |
| 122 | <p> | |
| 123 | The constructor function <code>ExplicitMultiplicationNearRing</code> returns the nearring | |
| 124 | defined by the group <var>G</var> and the nearring multiplication <var>mul</var>. | |
| 125 | (For a detailed explanation of <var>mul</var> see Section <a href="CHAP002.htm#SSEC001.1">IsNearRingMultiplication</a>.) | |
| 126 | <p> | |
| 127 | <code>ExplicitMultiplicationNearRing</code> calls | |
| 128 | <code>IsNearRingMultiplication</code> in order to make sure that | |
| 129 | <var>mul</var> is really a nearring multiplication. If the nearring | |
| 130 | multiplication should not be checked, | |
| 131 | <p> | |
| 132 | <a name = "SSEC002.2"></a> | |
| 133 | <li><code>ExplicitMultiplicationNearRingNC( </code><var>G</var><code>, </code><var>mul</var><code> )</code> | |
| 134 | <p> | |
| 135 | may be called. | |
| 136 | <p> | |
| 137 | <pre> | |
| 138 | gap> n := ExplicitMultiplicationNearRing( GTW18_3, mul_l ); | |
| 139 | ExplicitMultiplicationNearRing ( 18/3 , multiplication ) | |
| 140 | gap> n = ExplicitMultiplicationNearRingNC( GTW18_3, mul_l ); | |
| 141 | true | |
| 142 | </pre> | |
| 143 | <p> | |
| 144 | <a name = "SSEC002.3"></a> | |
| 145 | <li><code>IsNearRing( </code><var>obj</var><code> )</code> | |
| 146 | <p> | |
| 147 | <code>IsNearRing</code> returns <code>true</code> if the object <var>obj</var> is a nearring | |
| 148 | and <code>false</code> otherwise. | |
| 149 | <p> | |
| 150 | <pre> | |
| 151 | gap> n := ExplicitMultiplicationNearRingNC( GTW18_3, mul_l ); | |
| 152 | ExplicitMultiplicationNearRing ( 18/3 , multiplication ) | |
| 153 | gap> IsNearRing( n ); | |
| 154 | true | |
| 155 | gap> IsNearRing( GroupReduct( n ) ); | |
| 156 | false | |
| 157 | </pre> | |
| 158 | <p> | |
| 159 | <a name = "SSEC002.4"></a> | |
| 160 | <li><code>IsExplicitMultiplicationNearRing( </code><var>obj</var><code> )</code> | |
| 161 | <p> | |
| 162 | <code>IsExplicitMultiplicationNearRing</code> returns <code>true</code>, if the object <var>obj</var> is | |
| 163 | a nearring defined by a group and a multiplication as with | |
| 164 | <a href="CHAP002.htm#SSEC002.1">ExplicitMultiplicationNearRing</a>. | |
| 165 | <p> | |
| 166 | <pre> | |
| 167 | gap> IsExplicitMultiplicationNearRing( n ); | |
| 168 | true | |
| 169 | </pre> | |
| 170 | <p> | |
| 171 | <p> | |
| 172 | <h2><a name="SECT003">2.3 Direct products of nearrings</a></h2> | |
| 173 | <p><p> | |
| 174 | <a name = "SSEC003.1"></a> | |
| 175 | <li><code>DirectProductNearRing( </code><var>nr1</var><code>, </code><var>nr2</var><code> )</code> | |
| 176 | <p> | |
| 177 | Given two nearrings <var>nr1</var> and <var>nr2</var>, the function <code>DirectProductNearRing</code> | |
| 178 | constructs the direct product of these. | |
| 179 | <p> | |
| 180 | <pre> | |
| 181 | gap> n := ExplicitMultiplicationNearRingNC( GTW18_3, mul_l ); | |
| 182 | ExplicitMultiplicationNearRing ( 18/3 , multiplication ) | |
| 183 | gap> zero_mul := function ( x, y ) return (); end; | |
| 184 | function ( x, y ) ... end | |
| 185 | gap> z := ExplicitMultiplicationNearRingNC( GTW12_3, zero_mul ); | |
| 186 | ExplicitMultiplicationNearRing ( 12/3 , multiplication ) | |
| 187 | gap> d := DirectProductNearRing( n, z ); | |
| 188 | DirectProductNearRing( ExplicitMultiplicationNearRing ( 18/3 , multi\ | |
| 189 | plication ), ExplicitMultiplicationNearRing ( 12/3 , multiplication \ | |
| 190 | ) ) | |
| 191 | gap> IsExplicitMultiplicationNearRing( d ); | |
| 192 | true | |
| 193 | </pre> | |
| 194 | <p> | |
| 195 | <p> | |
| 196 | <h2><a name="SECT004">2.4 Operation tables for nearrings</a></h2> | |
| 197 | <p><p> | |
| 198 | <a name = "SSEC004.1"></a> | |
| 199 | <li><code>PrintTable( </code><var>nr</var><code> )</code> | |
| 200 | <p> | |
| 201 | <code>PrintTable</code> prints the additive and multiplicative Cayley tables of the | |
| 202 | nearring <var>nr</var>. This function works the same way as for groups. | |
| 203 | <p> | |
| 204 | <pre> | |
| 205 | gap> n := ExplicitMultiplicationNearRingNC( CyclicGroup( 3 ), mul_l ); | |
| 206 | ExplicitMultiplicationNearRing ( <pc group of size 3 with | |
| 207 | 1 generators> , multiplication ) | |
| 208 | gap> SetSymbols( n, ["0","1","2"] ); | |
| 209 | gap> PrintTable( n ); | |
| 210 | Let: | |
| 211 | 0 := (<identity> of ...) | |
| 212 | 1 := (f1) | |
| 213 | 2 := (f1^2) | |
| 214 | ||
| 215 | + | 0 1 2 | |
| 216 | ------------ | |
| 217 | 0 | 0 1 2 | |
| 218 | 1 | 1 2 0 | |
| 219 | 2 | 2 0 1 | |
| 220 | ||
| 221 | * | 0 1 2 | |
| 222 | ------------ | |
| 223 | 0 | 0 1 2 | |
| 224 | 1 | 0 1 2 | |
| 225 | 2 | 0 1 2 | |
| 226 | </pre> | |
| 227 | <p> | |
| 228 | Optionally, <code>PrintTable</code> can be used in the form <code>PrintTable( </code><var>nr</var><code>, </code><var>mode</var><code> )</code>, | |
| 229 | where <var>mode</var> is a string. If the letter <code>e</code> is contained in this string, the | |
| 230 | definitions of the symbols used are printed, if the letter <code>a</code> is contained | |
| 231 | in the string, the addition table is printed, and if the letter <code>m</code> is contained | |
| 232 | in the string, the multiplication table of the nearring is printed. Every | |
| 233 | combination of these three letters in any order is possible. | |
| 234 | <p> | |
| 235 | <p> | |
| 236 | <h2><a name="SECT005">2.5 Modified symbols for the operation tables</a></h2> | |
| 237 | <p><p> | |
| 238 | <a name = "SSEC005.1"></a> | |
| 239 | <li><code>SetSymbols( </code><var>nr</var><code>, </code><var>symblist</var><code> )</code> | |
| 240 | <a name = "SSEC005.1"></a> | |
| 241 | <li><code>SetSymbolsSupervised( </code><var>nr</var><code>, </code><var>symblist</var><code> )</code> | |
| 242 | <p> | |
| 243 | The function <code>SetSymbols</code> and <code>SetSymbolsSupervised</code> allow you to define a | |
| 244 | list <var>symblist</var> of strings to be used when printing the operation tables of | |
| 245 | the nearring. <code>SetSymbols</code> simply sets the set of strings to the given value. | |
| 246 | <code>SetSymbolsSupervised</code> checks, if there are more symbols than the nearring has | |
| 247 | elements. In this case the superfluous strings are ignored. If there are less | |
| 248 | symbols than the nearring has elements, <code>SetSymbolsSupervised</code> ``invents'' | |
| 249 | unique names for the rest of the elements. In any case a warning is printed. | |
| 250 | If there are repetitions or holes in the list <var>symblist</var> an error is signaled. | |
| 251 | <p> | |
| 252 | <a name = "SSEC005.2"></a> | |
| 253 | <li><code>Symbols( </code><var>nr</var><code> )</code> | |
| 254 | <p> | |
| 255 | allows you to look at the set of symbols, which are currently in use. | |
| 256 | <p> | |
| 257 | <pre> | |
| 258 | gap> n := LibraryNearRing( GTW3_1, 4 ); | |
| 259 | LibraryNearRing(3/1, 4) | |
| 260 | gap> Symbols( n ); | |
| 261 | [ "n0", "n1", "n2" ] | |
| 262 | gap> SetSymbolsSupervised( n, | |
| 263 | ["apple", "banana", "coconut", "donut", "potato"] ); | |
| 264 | Warning: too many symbols ...ignoring the last 2 symbols | |
| 265 | gap> PrintTable( n, "m" ); | |
| 266 | ||
| 267 | * | apple banana coconut | |
| 268 | ------------------------------------ | |
| 269 | apple | apple apple apple | |
| 270 | banana | apple banana coconut | |
| 271 | coconut | apple banana coconut | |
| 272 | </pre> | |
| 273 | <p> | |
| 274 | <p> | |
| 275 | <h2><a name="SECT006">2.6 Accessing nearring elements</a></h2> | |
| 276 | <p><p> | |
| 277 | The elements of a nearring are different from those of its group reduct. | |
| 278 | In order to make group elements and nearring elements distinguishable for the | |
| 279 | user, nearring elements are printed with an extra pair of parentheses. | |
| 280 | The two functions <code>AsGroupReductElement</code> and <code>AsNearRingElement</code> can be | |
| 281 | used to switch between these two representations. | |
| 282 | <p> | |
| 283 | <a name = "SSEC006.1"></a> | |
| 284 | <li><code>AsNearRingElement( </code><var>nr</var><code>, </code><var>grpelm</var><code> )</code> | |
| 285 | <p> | |
| 286 | returns the representation as a nearring element of an element <var>grpelm</var> of the | |
| 287 | group reduct of the nearring <var>nr</var>. | |
| 288 | <p> | |
| 289 | <a name = "SSEC006.2"></a> | |
| 290 | <li><code>AsGroupReductElement( </code><var>nrelm</var><code> )</code> | |
| 291 | <p> | |
| 292 | returns the representation as an element of the group reduct of the nearring | |
| 293 | of the nearring element <var>nrelm</var>. | |
| 294 | <p> | |
| 295 | <pre> | |
| 296 | gap> mul_l := function ( x, y ) return y; end; | |
| 297 | function ( x, y ) ... end | |
| 298 | gap> n := ExplicitMultiplicationNearRingNC( GTW6_2, mul_l ); | |
| 299 | ExplicitMultiplicationNearRing ( 6/2 , multiplication ) | |
| 300 | gap> AsList( n ); | |
| 301 | [ (()), ((2,3)), ((1,2)), ((1,2,3)), ((1,3,2)), ((1,3)) ] | |
| 302 | gap> e := AsNearRingElement( n, (2,3) ); | |
| 303 | ((2,3)) | |
| 304 | gap> e in n; | |
| 305 | true | |
| 306 | gap> f := AsNearRingElement( n, (1,3) ); | |
| 307 | ((1,3)) | |
| 308 | gap> e + f; | |
| 309 | ((1,3,2)) | |
| 310 | gap> e * f; | |
| 311 | ((1,3)) | |
| 312 | gap> p := AsGroupReductElement( e ); | |
| 313 | (2,3) | |
| 314 | gap> IsPerm( p ); | |
| 315 | true | |
| 316 | gap> p + p; | |
| 317 | Error no method found for operation SUM with 2 arguments at | |
| 318 | Error( "no method found for operation ", NAME_FUNC( operation ), | |
| 319 | " with 2 arguments" ); | |
| 320 | Entering break read-eval-print loop, you can 'quit;' to quit to outer l\ | |
| 321 | oop, | |
| 322 | or you can return to continue | |
| 323 | brk> | |
| 324 | </pre> | |
| 325 | <p> | |
| 326 | <p> | |
| 327 | <h2><a name="SECT007">2.7 Nearring elements</a></h2> | |
| 328 | <p><p> | |
| 329 | There are three different ways to ask for the elements of a nearring. | |
| 330 | <p> | |
| 331 | <a name = "SSEC007.1"></a> | |
| 332 | <li><code>AsList( </code><var>nr</var><code> )</code> | |
| 333 | <p> | |
| 334 | The function <code>AsList</code> computes the elements of the nearring <var>nr</var>. It returns | |
| 335 | the elements as a list. | |
| 336 | <p> | |
| 337 | <a name = "SSEC007.2"></a> | |
| 338 | <li><code>AsSortedList( </code><var>nr</var><code> )</code> | |
| 339 | <p> | |
| 340 | does essentially the same, but returns a set of elements. | |
| 341 | <p> | |
| 342 | <a name = "SSEC007.3"></a> | |
| 343 | <li><code>Enumerator( </code><var>nr</var><code> )</code> | |
| 344 | <p> | |
| 345 | does essentially the same as <code>AsList</code>, but returns an enumerator for the | |
| 346 | elements of <var>nr</var>. An enumerator is an object that is capable of enumerating | |
| 347 | the elements the nearring one by one. This is especially important if the | |
| 348 | nearring is very big and not every element can be stored. | |
| 349 | <p> | |
| 350 | <pre> | |
| 351 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 352 | LibraryNearRing(6/2, 39) | |
| 353 | gap> e := Enumerator( n ); | |
| 354 | <enumerator of near ring> | |
| 355 | gap> e[1]; | |
| 356 | (()) | |
| 357 | gap> x := AsNearRingElement( n, (1,2,3) ); | |
| 358 | ((1,2,3)) | |
| 359 | gap> Position( e, x ); | |
| 360 | 2 | |
| 361 | gap> Length(e); | |
| 362 | 6 | |
| 363 | gap> l := AsList( n ); | |
| 364 | [ (()), ((2,3)), ((1,2)), ((1,2,3)), ((1,3,2)), ((1,3)) ] | |
| 365 | gap> e[3] = l[3]; | |
| 366 | false | |
| 367 | gap> AsSortedList( n ); | |
| 368 | [ (()), ((2,3)), ((1,2)), ((1,2,3)), ((1,3,2)), ((1,3)) ] | |
| 369 | </pre> | |
| 370 | <p> | |
| 371 | <p> | |
| 372 | <h2><a name="SECT008">2.8 Random nearring elements</a></h2> | |
| 373 | <p><p> | |
| 374 | <a name = "SSEC008.1"></a> | |
| 375 | <li><code>Random( </code><var>nr</var><code> )</code> | |
| 376 | <p> | |
| 377 | <code>Random</code> returns a random element of the nearring <var>nr</var>. | |
| 378 | <p> | |
| 379 | <pre> | |
| 380 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 381 | LibraryNearRing(6/2, 39) | |
| 382 | gap> Random(n); | |
| 383 | ((1,3)) | |
| 384 | </pre> | |
| 385 | <p> | |
| 386 | <p> | |
| 387 | <h2><a name="SECT009">2.9 Nearring generators</a></h2> | |
| 388 | <p><p> | |
| 389 | <a name = "SSEC009.1"></a> | |
| 390 | <li><code>GeneratorsOfNearRing( </code><var>nr</var><code> )</code> | |
| 391 | <p> | |
| 392 | The function <code>GeneratorsOfNearRing</code> returns a set of (not necessarily | |
| 393 | additive) generators of the nearring <var>nr</var>. | |
| 394 | <p> | |
| 395 | <pre> | |
| 396 | gap> n := ExplicitMultiplicationNearRingNC( GTW8_4, mul_l ); | |
| 397 | ExplicitMultiplicationNearRing ( 8/4 , multiplication ) | |
| 398 | gap> GeneratorsOfNearRing( n ); | |
| 399 | [ ((1,2,3,4)), ((2,4)) ] | |
| 400 | </pre> | |
| 401 | <p> | |
| 402 | <p> | |
| 403 | <h2><a name="SECT010">2.10 Size of a nearring</a></h2> | |
| 404 | <p><p> | |
| 405 | <a name = "SSEC010.1"></a> | |
| 406 | <li><code>Size( </code><var>nr</var><code> )</code> | |
| 407 | <p> | |
| 408 | <code>Size</code> returns the number of elements in the nearring <var>nr</var>. | |
| 409 | <p> | |
| 410 | <pre> | |
| 411 | gap> n := LibraryNearRingWithOne( GTW24_3, 8 ); | |
| 412 | LibraryNearRingWithOne(24/3, 8) | |
| 413 | gap> Size(n); | |
| 414 | 24 | |
| 415 | </pre> | |
| 416 | <p> | |
| 417 | <p> | |
| 418 | <h2><a name="SECT011">2.11 The additive group of a nearring</a></h2> | |
| 419 | <p><p> | |
| 420 | <a name = "SSEC011.1"></a> | |
| 421 | <li><code>GroupReduct( </code><var>nr</var><code> )</code> | |
| 422 | <p> | |
| 423 | The function <code>GroupReduct</code> returns the nearring <var>nr</var> as a | |
| 424 | (multiplicative) group. | |
| 425 | <p> | |
| 426 | <pre> | |
| 427 | gap> GroupReduct( LibraryNearRingWithOne( GTW24_3, 8 ) ); | |
| 428 | 24/3 | |
| 429 | </pre> | |
| 430 | <p> | |
| 431 | <p> | |
| 432 | <h2><a name="SECT012">2.12 Nearring endomorphisms</a></h2> | |
| 433 | <p><p> | |
| 434 | <a name = "SSEC012.1"></a> | |
| 435 | <li><code>Endomorphisms( </code><var>nr</var><code> )</code> | |
| 436 | <p> | |
| 437 | <code>Endomorphisms</code> computes all the endomorphisms of the nearring <var>nr</var>. | |
| 438 | The endomorphisms are returned as a list of transformations. In fact, the | |
| 439 | returned list contains those endomorphisms of the group reduct of <var>nr</var> | |
| 440 | which are also nearring endomorphisms. | |
| 441 | <p> | |
| 442 | <pre> | |
| 443 | gap> Endomorphisms ( LibraryNearRing( GTW12_4, 4 ) ) ; | |
| 444 | [ [ (1,2,4), (2,3,4) ] -> [ (), () ], | |
| 445 | [ (1,2,4), (2,3,4) ] -> [ (1,2,4), (2,3,4) ] ] | |
| 446 | gap> Length( Endomorphisms( GTW12_4 ) ); | |
| 447 | 33 | |
| 448 | </pre> | |
| 449 | <p> | |
| 450 | <p> | |
| 451 | <h2><a name="SECT013">2.13 Nearring automorphisms</a></h2> | |
| 452 | <p><p> | |
| 453 | <a name = "SSEC013.1"></a> | |
| 454 | <li><code>Automorphisms( </code><var>nr</var><code> )</code> | |
| 455 | <p> | |
| 456 | <code>Automorphisms</code> computes all the automorphisms of the nearring <var>nr</var>. | |
| 457 | The automorphisms are returned as a list of transformations. In fact, the | |
| 458 | returned list contains those automorphisms of the group reduct of <var>nr</var> | |
| 459 | which are also nearring automorphisms. | |
| 460 | <p> | |
| 461 | <pre> | |
| 462 | gap> Automorphisms( LibraryNearRing( GTW12_4, 4 ) ); | |
| 463 | [ IdentityMapping( 12/4 ) ] | |
| 464 | </pre> | |
| 465 | <p> | |
| 466 | <p> | |
| 467 | <h2><a name="SECT014">2.14 Isomorphic nearrings</a></h2> | |
| 468 | <p><p> | |
| 469 | <a name = "SSEC014.1"></a> | |
| 470 | <li><code>IsIsomorphicNearRing( </code><var>nr1</var><code>, </code><var>nr2</var><code> )</code> | |
| 471 | <p> | |
| 472 | The function <code>IsIsomorphicNearRing</code> returns <code>true</code> if the two nearrings | |
| 473 | <var>nr1</var> and <var>nr2</var> are isomorphic and <code>false</code> otherwise. | |
| 474 | <p> | |
| 475 | <pre> | |
| 476 | gap> IsIsomorphicNearRing( MapNearRing( GTW2_1 ), | |
| 477 | > LibraryNearRingWithOne( GTW4_2, 5 ) ); | |
| 478 | true | |
| 479 | </pre> | |
| 480 | <p> | |
| 481 | <p> | |
| 482 | <h2><a name="SECT015">2.15 Subnearrings</a></h2> | |
| 483 | <p><p> | |
| 484 | <a name = "SSEC015.1"></a> | |
| 485 | <li><code>SubNearRings( </code><var>nr</var><code> )</code> | |
| 486 | <p> | |
| 487 | The function <code>SubNearRings</code> computes all subnearrings of the nearring | |
| 488 | <var>nr</var>. The function returns a list of nearrings representing the | |
| 489 | according subnearrings. | |
| 490 | <p> | |
| 491 | <pre> | |
| 492 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 493 | LibraryNearRing(12/4, 8) | |
| 494 | gap> SubNearRings( n ); | |
| 495 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 496 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3) ]) , multiplication ), | |
| 497 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 498 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 499 | ExplicitMultiplicationNearRing ( Group([ (1,2,4) ]) , multiplication ), | |
| 500 | ExplicitMultiplicationNearRing ( Group([ (1,3,2) ]) , multiplication ), | |
| 501 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 502 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3)(2,4) | |
| 503 | ]) , multiplication ), ExplicitMultiplicationNearRing ( Group( | |
| 504 | [ (1,4)(2,3), (1,3)(2,4), (2,3,4) ]) , multiplication ) ] | |
| 505 | </pre> | |
| 506 | <p> | |
| 507 | <p> | |
| 508 | <h2><a name="SECT016">2.16 Invariant subnearrings</a></h2> | |
| 509 | <p><p> | |
| 510 | <a name = "SSEC016.1"></a> | |
| 511 | <li><code>InvariantSubNearRings( </code><var>nr</var><code> )</code> | |
| 512 | <p> | |
| 513 | A subnearring (<i>M</i>,+,·) of a nearring (<i>N</i>,+,·) is called an | |
| 514 | <strong>invariant subnearring</strong> if both, <i>M</i> ·<i>N</i> and <i>N</i> ·<i>M</i> are subsets of <i>M</i>. | |
| 515 | <p> | |
| 516 | The function <code>InvariantSubNearRings</code> computes all invariant | |
| 517 | subnearrings of the nearring <var>nr</var>. | |
| 518 | The function returns a list of nearrings representing the according | |
| 519 | invariant subnearrings. | |
| 520 | <p> | |
| 521 | <pre> | |
| 522 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 523 | LibraryNearRing(12/4, 8) | |
| 524 | gap> i := InvariantSubNearRings( n ); | |
| 525 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 526 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 527 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 528 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 529 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3)(2,4), (2,3,4) | |
| 530 | ]) , multiplication ) ] | |
| 531 | </pre> | |
| 532 | <p> | |
| 533 | <p> | |
| 534 | <h2><a name="SECT017">2.17 Constructing subnearrings</a></h2> | |
| 535 | <p><p> | |
| 536 | <a name = "SSEC017.1"></a> | |
| 537 | <li><code>SubNearRingBySubgroupNC( </code><var>nr</var><code>, </code><var>S</var><code> )</code> | |
| 538 | <p> | |
| 539 | For a subgroup <var>S</var> of the group reduct of the nearring which is closed | |
| 540 | under the multiplication of <var>nr</var> the function | |
| 541 | <code>SubNearRingBySubgroupNC</code> returns the subnearRing of <var>nr</var>, which is | |
| 542 | induced by this subgroup. The <var>nr</var>-invariance is not expli[ly] | |
| 543 | tested. | |
| 544 | <p> | |
| 545 | <pre> | |
| 546 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 547 | LibraryNearRing(12/4, 8) | |
| 548 | gap> S := Subgroup( GTW12_4, [ (1,2)(3,4) ] ); | |
| 549 | Group([ (1,2)(3,4) ]) | |
| 550 | gap> sn := SubNearRingBySubgroupNC( n, S ); | |
| 551 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ) | |
| 552 | </pre> | |
| 553 | <p> | |
| 554 | <p> | |
| 555 | <h2><a name="SECT018">2.18 Intersection of nearrings</a></h2> | |
| 556 | <p><p> | |
| 557 | <a name = "SSEC018.1"></a> | |
| 558 | <li><code>Intersection( </code><var>listofnrs</var><code> )</code> | |
| 559 | <p> | |
| 560 | computes the intersection of the nearrings in the list <var>listofnrs</var>. | |
| 561 | All of the nearrings in <var>listofnrs</var> must be subnearrings of a common | |
| 562 | supernearring. | |
| 563 | <p> | |
| 564 | <pre> | |
| 565 | gap> n := LibraryNearRingWithOne( GTW27_4, 5 ); | |
| 566 | LibraryNearRingWithOne(27/4, 5) | |
| 567 | gap> si := Filtered( SubNearRings( n ), s -> Identity( n ) in s ); | |
| 568 | [ ExplicitMultiplicationNearRing ( Group( | |
| 569 | [ (1,23,14)(2,13,6)(3,27,22)(4,18,9)(5,20,12)(7,16,26)(8,25,17)(10,21, | |
| 570 | 19)(11,24,15) ]) , multiplication ), | |
| 571 | ExplicitMultiplicationNearRing ( Group( | |
| 572 | [ (1,26,27)(2,19,20)(3,14,16)(4,24,25)(5,6,21)(7,22,23)(8,9,11)(10,12, | |
| 573 | 13)(15,17,18), (1,22,16)(2,12,21)(3,26,23)(4,17,11)(5,19,13)(6,20, | |
| 574 | 10)(7,14,27)(8,24,18)(9,25,15) ]) , multiplication ), | |
| 575 | ExplicitMultiplicationNearRing ( Group( | |
| 576 | [ (1,17,5)(2,22,8)(3,4,12)(6,26,18)(7,11,20)(9,19,23)(10,16,25)(13,14, | |
| 577 | 24)(15,21,27), (1,15,6)(2,7,9)(3,25,13)(4,10,14)(5,27,18)(8,20,23)(11, | |
| 578 | 19,22)(12,16,24)(17,21,26), (1,2,4)(3,6,11)(5,9,16)(7,13,17)(8,14, | |
| 579 | 21)(10,18,22)(12,15,23)(19,24,26)(20,25,27) ]) , multiplication ) ] | |
| 580 | gap> Intersection( si ); | |
| 581 | ExplicitMultiplicationNearRing ( Group( | |
| 582 | [ (1,23,14)(2,13,6)(3,27,22)(4,18,9)(5,20,12)(7,16,26)(8,25,17)(10,21,19)(11, | |
| 583 | 24,15) ]) , multiplication ) | |
| 584 | gap> Size( last ); | |
| 585 | 3 | |
| 586 | </pre> | |
| 587 | <p> | |
| 588 | <p> | |
| 589 | <h2><a name="SECT019">2.19 Identity of a nearring</a></h2> | |
| 590 | <p><p> | |
| 591 | <a name = "SSEC019.1"></a> | |
| 592 | <li><code>Identity( </code><var>nr</var><code> )</code> | |
| 593 | <p> | |
| 594 | <a name = "SSEC019.2"></a> | |
| 595 | <li><code>One( </code><var>nr</var><code> )</code> | |
| 596 | <p> | |
| 597 | The functions <code>Identity</code> and <code>One</code> return the identity of the multiplicative | |
| 598 | semigroup of the nearring <var>nr</var> if it exists and <code>fail</code> otherwise. | |
| 599 | <p> | |
| 600 | <pre> | |
| 601 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 602 | LibraryNearRing(12/4, 8) | |
| 603 | gap> Identity( n ); | |
| 604 | fail | |
| 605 | gap> One( n ); | |
| 606 | fail | |
| 607 | gap> n := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 608 | LibraryNearRingWithOne(24/4, 8) | |
| 609 | gap> Identity( n ); | |
| 610 | ((1,2,3,4,5,6)(7,8)) | |
| 611 | gap> One( n ); | |
| 612 | ((1,2,3,4,5,6)(7,8)) | |
| 613 | </pre> | |
| 614 | <p> | |
| 615 | <a name = "SSEC019.3"></a> | |
| 616 | <li><code>IsNearRingWithOne( </code><var>nr</var><code> )</code> | |
| 617 | <p> | |
| 618 | The function <code>IsNearRingWithOne</code> returns <code>true</code> if the nearring was | |
| 619 | constructed as a nearring with one and <code>false</code> otherwise. To decide | |
| 620 | whether a nearring has an identity use <code>Identity(</code><var>nr</var><code>)=true</code>. | |
| 621 | <p> | |
| 622 | <pre> | |
| 623 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 624 | LibraryNearRing(12/4, 8) | |
| 625 | gap> IsNearRingWithOne( n ); | |
| 626 | false | |
| 627 | gap> n := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 628 | LibraryNearRingWithOne(24/4, 8) | |
| 629 | gap> Identity( n ); | |
| 630 | ((1,2,3,4,5,6)(7,8)) | |
| 631 | gap> IsNearRingWithOne( n ); | |
| 632 | false | |
| 633 | </pre> | |
| 634 | <p> | |
| 635 | <p> | |
| 636 | <h2><a name="SECT020">2.20 Units of a nearring</a></h2> | |
| 637 | <p><p> | |
| 638 | <a name = "SSEC020.1"></a> | |
| 639 | <li><code>IsNearRingUnit( </code><var>nr</var><code>, </code><var>x</var><code> )</code> | |
| 640 | <p> | |
| 641 | An element <i>x</i> of a nearring (<i>N</i>,+,·) with identity 1 is called a <hr>unit | |
| 642 | if there exists an element <i>y</i> in <i>N</i> such that <i>x</i>·<i>y</i> = <i>y</i>·<i>x</i> = 1. | |
| 643 | <p> | |
| 644 | The function <code>IsNearRingUnit</code> returns <code>true</code> if <var>x</var> is a unit in <var>nr</var> and | |
| 645 | false otherwise. | |
| 646 | <p> | |
| 647 | <a name = "SSEC020.2"></a> | |
| 648 | <li><code>NearRingUnits( </code><var>nr</var><code> )</code> | |
| 649 | <p> | |
| 650 | <code>NearRingUnits</code> returns the units of the nearring <var>nr</var> either as | |
| 651 | multiplicative group or list. | |
| 652 | <p> | |
| 653 | <pre> | |
| 654 | gap> n := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 655 | LibraryNearRingWithOne(24/4, 8) | |
| 656 | gap> NearRingUnits( n ); | |
| 657 | [ ((1,2,3,4,5,6)(7,8)), ((1,6,5,4,3,2)(7,8)) ] | |
| 658 | </pre> | |
| 659 | <p> | |
| 660 | <p> | |
| 661 | <h2><a name="SECT021">2.21 Distributivity in a nearring</a></h2> | |
| 662 | <p><p> | |
| 663 | <a name = "SSEC021.1"></a> | |
| 664 | <li><code>Distributors( </code><var>nr</var><code> )</code> | |
| 665 | <p> | |
| 666 | An element <i>x</i> of a nearring (<i>N</i>,+,·) is called a <hr>distributor | |
| 667 | if <i>x</i> = (<i>n</i><sub>1</sub> + <i>n</i><sub>2</sub> ) ·<i>n</i><sub>3</sub> <font face="symbol">-</font> (<i>n</i><sub>1</sub> ·<i>n</i><sub>3</sub> + <i>n</i><sub>2</sub> ·<i>n</i><sub>3</sub> ) for some elements | |
| 668 | <i>n</i><sub>1</sub>, <i>n</i><sub>2</sub>, <i>n</i><sub>3</sub> of <i>N</i>. | |
| 669 | <p> | |
| 670 | The function <code>Distributors</code> returns a list containing the distributors | |
| 671 | of the nearring <var>nr</var>. | |
| 672 | <p> | |
| 673 | <pre> | |
| 674 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 675 | LibraryNearRing(12/4, 8) | |
| 676 | gap> IsNearRingWithOne( n ); | |
| 677 | false | |
| 678 | gap> Distributors( n ); | |
| 679 | [ (()), ((2,3,4)), ((2,4,3)), ((1,2)(3,4)), ((1,2,3)), ((1,2,4)), | |
| 680 | ((1,3,2)), ((1,3,4)), ((1,3)(2,4)), ((1,4,2)), ((1,4,3)), | |
| 681 | ((1,4)(2,3)) ] | |
| 682 | </pre> | |
| 683 | <p> | |
| 684 | <a name = "SSEC021.2"></a> | |
| 685 | <li><code>DistributiveElements( </code><var>nr</var><code> )</code> | |
| 686 | <p> | |
| 687 | An element <i>d</i> of a left nearring (<i>N</i>,+,·) is called a | |
| 688 | <strong>distributive element</strong> if it is also right distributive over all elements, | |
| 689 | i.e. <font face="symbol">"</font><i>n</i><sub>1</sub>, <i>n</i><sub>2</sub> <font face="symbol">Î</font> <i>N</i>: (<i>n</i><sub>1</sub> + <i>n</i><sub>2</sub> )·<i>d</i> = <i>n</i><sub>1</sub>·<i>d</i> + <i>n</i><sub>2</sub>·<i>d</i>. | |
| 690 | <p> | |
| 691 | The function <code>DistributiveElements</code> returns a list containing the | |
| 692 | distributive elements of the nearring <var>nr</var>. | |
| 693 | <p> | |
| 694 | <pre> | |
| 695 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 696 | LibraryNearRing(12/4, 8) | |
| 697 | gap> DistributiveElements( n ); | |
| 698 | [ (()) ] | |
| 699 | </pre> | |
| 700 | <p> | |
| 701 | <a name = "SSEC021.3"></a> | |
| 702 | <li><code>IsDistributiveNearRing( </code><var>nr</var><code> )</code> | |
| 703 | <p> | |
| 704 | A left nearring <i>N</i> is called <strong>distributive nearring</strong> if its | |
| 705 | multiplication is also right distributive. | |
| 706 | <p> | |
| 707 | The function <code>IsDistributiveNearRing</code> simply checks if all elements | |
| 708 | are distributive and returns the according boolean value | |
| 709 | <code>true</code> or <code>false</code>. | |
| 710 | <p> | |
| 711 | <pre> | |
| 712 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 713 | LibraryNearRing(12/4, 8) | |
| 714 | gap> IsDistributiveNearRing( n ); | |
| 715 | false | |
| 716 | </pre> | |
| 717 | <p> | |
| 718 | <p> | |
| 719 | <h2><a name="SECT022">2.22 Elements of a nearring with special properties</a></h2> | |
| 720 | <p><p> | |
| 721 | <a name = "SSEC022.1"></a> | |
| 722 | <li><code>ZeroSymmetricElements( </code><var>nr</var><code> )</code> | |
| 723 | <p> | |
| 724 | Let (<i>N</i>,+,·) be a left nearring and denote by 0 the neutral element | |
| 725 | of (<i>N</i>,+). | |
| 726 | An element <i>n</i> of <i>N</i> is called a <strong>zero-symmetric element</strong> if 0·<i>n</i> = 0. | |
| 727 | <p> | |
| 728 | <strong>Remark:</strong> note that in a <strong>left</strong> nearring <i>n</i>·0 = 0 is true for all elements | |
| 729 | <i>n</i>. | |
| 730 | <p> | |
| 731 | The function <code>ZeroSymmetricElements</code> returns a list containing the | |
| 732 | zero-symmetric elements of the nearring <var>nr</var>. | |
| 733 | <p> | |
| 734 | <pre> | |
| 735 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 736 | LibraryNearRing(12/4, 8) | |
| 737 | gap> ZeroSymmetricElements( n ); | |
| 738 | [ (()), ((2,3,4)), ((2,4,3)), ((1,2)(3,4)), ((1,2,3)), ((1,2,4)), | |
| 739 | ((1,3,2)), ((1,3,4)), ((1,3)(2,4)), ((1,4,2)), ((1,4,3)), | |
| 740 | ((1,4)(2,3)) ] | |
| 741 | </pre> | |
| 742 | <p> | |
| 743 | <a name = "SSEC022.2"></a> | |
| 744 | <li><code>IdempotentElements( </code><var>nr</var><code> )</code> | |
| 745 | <p> | |
| 746 | The function <code>IdempotentElements</code> returns a list containing the | |
| 747 | idempotent elements of the multiplicative semigroup of the nearring <var>nr</var>. | |
| 748 | <p> | |
| 749 | <pre> | |
| 750 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 751 | LibraryNearRing(12/4, 8) | |
| 752 | gap> IdempotentElements( n ); | |
| 753 | [ (()), ((1,4)(2,3)) ] | |
| 754 | </pre> | |
| 755 | <p> | |
| 756 | <a name = "SSEC022.3"></a> | |
| 757 | <li><code>NilpotentElements( </code><var>nr</var><code> )</code> | |
| 758 | <p> | |
| 759 | Let (<i>N</i>,+,·) be a nearring with zero 0. An element <i>n</i> of <i>N</i> is | |
| 760 | called <strong>nilpotent</strong> if there is a positive integer <i>k</i> such that | |
| 761 | <i>n</i><sup><i>k</i></sup> = 0. | |
| 762 | <p> | |
| 763 | The function <code>NilpotentElements</code> returns a list of sublists of length | |
| 764 | 2 where the first entry is a nilpotent element <i>n</i> and the second | |
| 765 | entry is the smallest <i>k</i> such that <i>n</i><sup><i>k</i></sup> = 0. | |
| 766 | <p> | |
| 767 | <pre> | |
| 768 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 769 | LibraryNearRing(12/4, 8) | |
| 770 | gap> NilpotentElements( n ); | |
| 771 | [ [ (()), 1 ], [ ((2,3,4)), 2 ], [ ((2,4,3)), 2 ], | |
| 772 | [ ((1,2)(3,4)), 2 ], [ ((1,2,3)), 2 ], [ ((1,2,4)), 2 ], | |
| 773 | [ ((1,3,2)), 2 ], [ ((1,3,4)), 2 ], [ ((1,4,2)), 2 ], | |
| 774 | [ ((1,4,3)), 2 ] ] | |
| 775 | </pre> | |
| 776 | <p> | |
| 777 | <a name = "SSEC022.4"></a> | |
| 778 | <li><code>QuasiregularElements( </code><var>nr</var><code> )</code> | |
| 779 | <p> | |
| 780 | Let (<i>N</i>,+,·) be a left nearring. For an element <i>z</i> <font face="symbol">Î</font> <i>N</i>, | |
| 781 | denote the right ideal generated by the set {<i>n</i> <font face="symbol">-</font> <i>z</i>·<i>n</i> <font face="symbol">|</font> <i>n</i> <font face="symbol">Î</font> <i>N</i>} | |
| 782 | by <i>L</i><sub><i>z</i></sub>. | |
| 783 | An element <i>z</i> of <i>N</i> is called <strong>quasiregular</strong> if <i>z</i> <font face="symbol">Î</font> <i>L</i><sub><i>z</i></sub>. | |
| 784 | <p> | |
| 785 | The function <code>QuasiregularElements</code> returns a list of all | |
| 786 | quasiregular elements of a nearring <var>nr</var>. | |
| 787 | <p> | |
| 788 | <pre> | |
| 789 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 790 | LibraryNearRing(12/4, 8) | |
| 791 | gap> QuasiregularElements( n ); | |
| 792 | [ (()), ((2,3,4)), ((2,4,3)), ((1,2)(3,4)), ((1,2,3)), ((1,2,4)), | |
| 793 | ((1,3,2)), ((1,3,4)), ((1,3)(2,4)), ((1,4,2)), ((1,4,3)) ] | |
| 794 | </pre> | |
| 795 | <p> | |
| 796 | <a name = "SSEC022.5"></a> | |
| 797 | <li><code>RegularElements( </code><var>nr</var><code> )</code> | |
| 798 | <p> | |
| 799 | Let (<i>N</i>,+,·) be a nearring. An element <i>n</i> of <i>N</i> is called <strong>regular</strong> if | |
| 800 | there is an element <i>x</i> such that <i>n</i>·<i>x</i>·<i>n</i> = <i>n</i>. | |
| 801 | <p> | |
| 802 | The function <code>RegularElements</code> returns a list of all regular elements of a | |
| 803 | nearring <var>nr</var>. | |
| 804 | <p> | |
| 805 | <pre> | |
| 806 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 807 | LibraryNearRing(12/4, 8) | |
| 808 | gap> RegularElements( n ); | |
| 809 | [ (()), ((1,3)(2,4)), ((1,4)(2,3)) ] | |
| 810 | </pre> | |
| 811 | <p> | |
| 812 | <p> | |
| 813 | <h2><a name="SECT023">2.23 Special properties of a nearring</a></h2> | |
| 814 | <p><p> | |
| 815 | <a name = "SSEC023.1"></a> | |
| 816 | <li><code>IsAbelianNearRing( </code><var>nr</var><code> )</code> | |
| 817 | <p> | |
| 818 | A nearring is called <strong>abelian</strong> if its group reduct is abelian. | |
| 819 | <p> | |
| 820 | The function <code>IsAbelianNearRing</code> returns the according boolean value | |
| 821 | <code>true</code> or <code>false</code>. | |
| 822 | <p> | |
| 823 | <pre> | |
| 824 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 825 | LibraryNearRing(12/4, 8) | |
| 826 | gap> IsAbelianNearRing( n ); | |
| 827 | false | |
| 828 | </pre> | |
| 829 | <p> | |
| 830 | <a name = "SSEC023.2"></a> | |
| 831 | <li><code>IsAbstractAffineNearRing( </code><var>nr</var><code> )</code> | |
| 832 | <p> | |
| 833 | A left nearring <i>N</i> is called <strong>abstract affine</strong> if its group reduct is | |
| 834 | abelian and its zero-symmetric elements are exactly its distributive | |
| 835 | elements. | |
| 836 | <p> | |
| 837 | The function <code>IsAbstractAffineNearRing</code> returns the according boolean | |
| 838 | value <code>true</code> or <code>false</code>. | |
| 839 | <p> | |
| 840 | <pre> | |
| 841 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 842 | LibraryNearRing(12/4, 8) | |
| 843 | gap> IsAbstractAffineNearRing( n ); | |
| 844 | false | |
| 845 | </pre> | |
| 846 | <p> | |
| 847 | <a name = "SSEC023.3"></a> | |
| 848 | <li><code>IsBooleanNearRing( </code><var>nr</var><code> )</code> | |
| 849 | <p> | |
| 850 | A left nearring <i>N</i> is called <strong>boolean</strong> if all its elements are | |
| 851 | idempotent with respect to multiplication. | |
| 852 | <p> | |
| 853 | The function <code>IsBooleanNearRing</code> simply checks if all elements | |
| 854 | are idempotent and returns the according boolean value | |
| 855 | <code>true</code> or <code>false</code>. | |
| 856 | <p> | |
| 857 | <pre> | |
| 858 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 859 | LibraryNearRing(12/4, 8) | |
| 860 | gap> IsBooleanNearRing( n ); | |
| 861 | false | |
| 862 | </pre> | |
| 863 | <p> | |
| 864 | <a name = "SSEC023.4"></a> | |
| 865 | <li><code>IsNilNearRing( </code><var>nr</var><code> )</code> | |
| 866 | <p> | |
| 867 | A nearring <i>N</i> is called <strong>nil</strong> if all its elements are nilpotent. | |
| 868 | <p> | |
| 869 | The function <code>IsNilNearRing</code> checks if all elements are nilpotent and returns | |
| 870 | the according boolean value <code>true</code> or <code>false</code>. | |
| 871 | <p> | |
| 872 | <pre> | |
| 873 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 874 | LibraryNearRing(12/4, 8) | |
| 875 | gap> IsNilNearRing( n ); | |
| 876 | false | |
| 877 | </pre> | |
| 878 | <p> | |
| 879 | <a name = "SSEC023.5"></a> | |
| 880 | <li><code>IsNilpotentNearRing( </code><var>nr</var><code> )</code> | |
| 881 | <p> | |
| 882 | A nearring <i>N</i> is called <strong>nilpotent</strong> if there is a positive integer | |
| 883 | <i>k</i>, s.t. <i>N</i><sup><i>k</i></sup> = {0}. | |
| 884 | <p> | |
| 885 | The function <code>IsNilpotentNearRing</code> tests if | |
| 886 | the nearring <var>nr</var> is nilpotent and returns the according boolean value | |
| 887 | <code>true</code> or <code>false</code>. | |
| 888 | <p> | |
| 889 | <pre> | |
| 890 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 891 | LibraryNearRing(12/4, 8) | |
| 892 | gap> IsNilpotentNearRing( n ); | |
| 893 | false | |
| 894 | </pre> | |
| 895 | <p> | |
| 896 | <a name = "SSEC023.6"></a> | |
| 897 | <li><code>IsNilpotentFreeNearRing( </code><var>nr</var><code> )</code> | |
| 898 | <p> | |
| 899 | A nearring <i>N</i> is called <strong>nilpotent free</strong> if its only nilpotent | |
| 900 | element is 0. | |
| 901 | <p> | |
| 902 | The function <code>IsNilpotentFreeNearRing</code> checks if | |
| 903 | 0 is the only nilpotent and returns the according boolean value | |
| 904 | <code>true</code> or <code>false</code>. | |
| 905 | <p> | |
| 906 | <pre> | |
| 907 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 908 | LibraryNearRing(12/4, 8) | |
| 909 | gap> IsNilpotentFreeNearRing( n ); | |
| 910 | false | |
| 911 | </pre> | |
| 912 | <p> | |
| 913 | <a name = "SSEC023.7"></a> | |
| 914 | <li><code>IsCommutative( </code><var>nr</var><code> )</code> | |
| 915 | <p> | |
| 916 | A nearring (<i>N</i>,+,·) is called <strong>commutative</strong> if its multiplicative semigroup | |
| 917 | is commutative. | |
| 918 | <p> | |
| 919 | The function <code>IsCommutative</code> returns the according value <code>true</code> or <code>false</code>. | |
| 920 | <p> | |
| 921 | <pre> | |
| 922 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 923 | LibraryNearRing(12/4, 8) | |
| 924 | gap> IsCommutative( n ); | |
| 925 | false | |
| 926 | </pre> | |
| 927 | <p> | |
| 928 | <a name = "SSEC023.8"></a> | |
| 929 | <li><code>IsDgNearRing( </code><var>nr</var><code> )</code> | |
| 930 | <p> | |
| 931 | A nearring (<i>N</i>,+,·) is called <strong>distributively generated (d.g.)</strong> if | |
| 932 | (<i>N</i>,+) is generated additively by the distributive elements of the | |
| 933 | nearring. | |
| 934 | <p> | |
| 935 | The function <code>IsDgNearRing</code> returns the according value <code>true</code> or <code>false</code> | |
| 936 | for a nearring <var>nr</var>. | |
| 937 | <p> | |
| 938 | <pre> | |
| 939 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 940 | LibraryNearRing(12/4, 8) | |
| 941 | gap> IsDgNearRing( n ); | |
| 942 | false | |
| 943 | </pre> | |
| 944 | <p> | |
| 945 | <a name = "SSEC023.9"></a> | |
| 946 | <li><code>IsIntegralNearRing( </code><var>nr</var><code> )</code> | |
| 947 | <p> | |
| 948 | A nearring (<i>N</i>,+,·) with zero element 0 is called <strong>integral</strong> if | |
| 949 | it has no zero divisors, i.e. the condition <font face="symbol">"</font><i>n</i><sub>1</sub>,<i>n</i><sub>2</sub>: <i>n</i><sub>1</sub> ·<i>n</i><sub>2</sub> = 0 <font face="symbol">Þ</font> <i>n</i><sub>1</sub> = 0 <font face="symbol">Ú</font><i>n</i><sub>2</sub> = 0 holds. | |
| 950 | <p> | |
| 951 | The function <code>IsIntegralNearRing</code> returns | |
| 952 | the according value <code>true</code> or <code>false</code> for a nearring <var>nr</var>. | |
| 953 | <p> | |
| 954 | <pre> | |
| 955 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 956 | LibraryNearRing(12/4, 8) | |
| 957 | gap> IsIntegralNearRing( n ); | |
| 958 | false | |
| 959 | </pre> | |
| 960 | <p> | |
| 961 | <a name = "SSEC023.10"></a> | |
| 962 | <li><code>IsPrimeNearRing( </code><var>nr</var><code> )</code> | |
| 963 | <p> | |
| 964 | A nearring (<i>N</i>,+,·) with zero element 0 is called <strong>prime</strong> if | |
| 965 | the ideal { 0 } is a prime ideal. | |
| 966 | <p> | |
| 967 | The function <code>IsPrimeNearRing</code> checks if <var>nr</var> is a prime nearring | |
| 968 | by using the condition <var>for all non-zero ideals</var> <i>I</i>,<i>J</i>: <i>I</i> ·<i>J</i> <font face="symbol">¹</font> { 0 } and returns the according value <code>true</code> or <code>false</code>. | |
| 969 | <p> | |
| 970 | <pre> | |
| 971 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 972 | LibraryNearRing(12/4, 8) | |
| 973 | gap> IsPrimeNearRing( n ); | |
| 974 | true | |
| 975 | </pre> | |
| 976 | <p> | |
| 977 | <a name = "SSEC023.11"></a> | |
| 978 | <li><code>IsQuasiregularNearRing( </code><var>nr</var><code> )</code> | |
| 979 | <p> | |
| 980 | A nearring <i>N</i> is called <strong>quasiregular</strong> if all its elements are | |
| 981 | quasiregular. | |
| 982 | <p> | |
| 983 | The function <code>IsQuasiregularNearRing</code> simply checks if all elements | |
| 984 | of the nearring <var>nr</var> are quasiregular and returns the according | |
| 985 | boolean value <code>true</code> or <code>false</code>. | |
| 986 | <p> | |
| 987 | <pre> | |
| 988 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 989 | LibraryNearRing(12/4, 8) | |
| 990 | gap> IsQuasiregularNearRing( n ); | |
| 991 | false | |
| 992 | </pre> | |
| 993 | <p> | |
| 994 | <a name = "SSEC023.12"></a> | |
| 995 | <li><code>IsRegularNearRing( </code><var>nr</var><code> )</code> | |
| 996 | <p> | |
| 997 | A nearring <i>N</i> is called <strong>regular</strong> if all its elements are regular. | |
| 998 | <p> | |
| 999 | The function <code>IsRegularNearRing</code> simply checks if all elements | |
| 1000 | of the nearring <var>nr</var> are regular and returns the according | |
| 1001 | boolean value <code>true</code> or <code>false</code>. | |
| 1002 | <p> | |
| 1003 | <pre> | |
| 1004 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 1005 | LibraryNearRing(12/4, 8) | |
| 1006 | gap> IsRegularNearRing( n ); | |
| 1007 | false | |
| 1008 | </pre> | |
| 1009 | <p> | |
| 1010 | <a name = "SSEC023.13"></a> | |
| 1011 | <li><code>IsNearField( </code><var>nr</var><code> )</code> | |
| 1012 | <p> | |
| 1013 | Let (<i>N</i>,+,·) be a nearring with zero 0 and denote by <i>N</i><sup>*</sup> | |
| 1014 | the set <i>N</i> <font face="symbol">-</font> {0}. N is a <strong>nearfield</strong> if (<i>N</i>,+,·) has an identity and | |
| 1015 | (<i>N</i><sup>*</sup>,·) is a group. | |
| 1016 | <p> | |
| 1017 | The function <code>IsNearField</code> tests if <var>nr</var> has an identity and | |
| 1018 | if every non-zero element has a multiplicative inverse and returns | |
| 1019 | the according value <code>true</code> or <code>false</code>. | |
| 1020 | <p> | |
| 1021 | <pre> | |
| 1022 | gap> n := LibraryNearRing( GTW12_4, 8 ); | |
| 1023 | LibraryNearRing(12/4, 8) | |
| 1024 | gap> IsNearField( n ); | |
| 1025 | false | |
| 1026 | </pre> | |
| 1027 | <p> | |
| 1028 | <a name = "SSEC023.14"></a> | |
| 1029 | <li><code>IsPlanarNearRing( </code><var>nr</var><code> )</code> | |
| 1030 | <p> | |
| 1031 | Let (<i>N</i>,+,·) be a left nearring. For <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i> we define <i>a</i> <font face="symbol">º</font> <i>b</i> | |
| 1032 | iff <i>a</i>·<i>n</i> = <i>b</i>·<i>n</i> for all <i>n</i> <font face="symbol">Î</font> <i>N</i>. If <i>a</i> <font face="symbol">º</font> <i>b</i>, then <i>a</i> and <i>b</i> | |
| 1033 | are called <strong>equivalent multipliers</strong>. | |
| 1034 | A nearring <i>N</i> is called <strong>planar</strong> if <font face="symbol">|</font> <i>N</i>/<sub> <font face="symbol">º</font> </sub> <font face="symbol">|</font> <font face="symbol">³</font> 3 and if | |
| 1035 | for any two non-equivalent multipliers <i>a</i> and <i>b</i> in <i>N</i>, for any <i>c</i> <font face="symbol">Î</font> <i>N</i>, | |
| 1036 | the equation <i>a</i>·<i>x</i> = <i>b</i>·<i>x</i> + <i>c</i> has a unique solution. | |
| 1037 | <p> | |
| 1038 | The function <code>IsPlanarNearRing</code> returns the according value <code>true</code> or | |
| 1039 | <code>false</code> for a nearring <var>nr</var>. | |
| 1040 | <p> | |
| 1041 | <pre> | |
| 1042 | gap> n := LibraryNearRing( GTW9_2, 90 ); | |
| 1043 | LibraryNearRing(9/2, 90) | |
| 1044 | gap> IsPlanarNearRing( n ); | |
| 1045 | true | |
| 1046 | </pre> | |
| 1047 | <p> | |
| 1048 | <a name = "SSEC023.15"></a> | |
| 1049 | <li><code>IsWdNearRing( </code><var>nr</var><code> )</code> | |
| 1050 | <p> | |
| 1051 | A left nearring (<i>N</i>,+,·) is called <strong>weakly divisible</strong> if | |
| 1052 | <font face="symbol">"</font><i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i> <font face="symbol">$</font><i>x</i> <font face="symbol">Î</font> <i>N</i> : <i>a</i>·<i>x</i>=<i>b</i> or <i>b</i>·<i>x</i>=<i>a</i>. | |
| 1053 | <p> | |
| 1054 | The function <code>IsWdNearRing</code> returns the according value <var>true</var> or <var>false</var> | |
| 1055 | for the nearring <var>nr</var>. | |
| 1056 | <p> | |
| 1057 | <pre> | |
| 1058 | gap> nr := LibraryNearRing( GTW9_1, 185 ); | |
| 1059 | LibraryNearRing(9/1, 185) | |
| 1060 | gap> IsWdNearRing( nr ); | |
| 1061 | true | |
| 1062 | </pre> | |
| 1063 | <p> | |
| 1064 | <p> | |
| 1065 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 1066 | <P> | |
| 1067 | <address>SONATA manual<br>October 2018 | |
| 1068 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 3 The nearring library</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Previous</a>] [<a href ="CHAP004.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>3 The nearring library</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP003.htm#SECT001">Extracting nearrings from the library</a> | |
| 8 | <li> <A HREF="CHAP003.htm#SECT002">Identifying nearrings</a> | |
| 9 | <li> <A HREF="CHAP003.htm#SECT003">IsLibraryNearRing</a> | |
| 10 | <li> <A HREF="CHAP003.htm#SECT004">Accessing the information about a nearring stored in the library</a> | |
| 11 | </ol><p> | |
| 12 | <p> | |
| 13 | The nearring library contains all nearrings up to order 15 and all | |
| 14 | nearrings with identity up to order 31. All nearrings in the library are | |
| 15 | nearrings constructed via <code>ExplicitMultiplicationNearRingNC</code>, so all functions | |
| 16 | for these nearrings are applicable to <code>LibraryNearRing</code>s. | |
| 17 | <p> | |
| 18 | <p> | |
| 19 | <h2><a name="SECT001">3.1 Extracting nearrings from the library</a></h2> | |
| 20 | <p><p> | |
| 21 | <a name = "SSEC001.1"></a> | |
| 22 | <li><code>LibraryNearRing( </code><var>G</var><code>, </code><var>num</var><code> )</code> | |
| 23 | <p> | |
| 24 | <code>LibraryNearRing</code> retrieves a nearring from the nearrings library files. | |
| 25 | <var>G</var> must be a group of order <font face="symbol">£</font> 15. <var>num</var> must be an integer which | |
| 26 | indicates the number of the class of nearrings on the specified group. | |
| 27 | <p> | |
| 28 | (<var>Remark:</var> due to the large number of nearrings on <i>D</i><sub>12</sub>, make sure | |
| 29 | that you have enough main memory - say at least 32 MB - available if you want | |
| 30 | to get a library nearring on <i>D</i><sub>12</sub>). | |
| 31 | <p> | |
| 32 | If <var>G</var> is given as a <code>TWGroup</code>, then a nearring is returned whose group reduct | |
| 33 | is <strong>equal to</strong> <var>G</var>. Otherwise the result is a nearring whose group reduct is | |
| 34 | <strong>isomorphic to</strong> <var>G</var>, and a warning is issued. | |
| 35 | <p> | |
| 36 | The number of nearrings definable on a certain group <var>G</var> can be accessed via | |
| 37 | <p> | |
| 38 | <a name = "SSEC001.2"></a> | |
| 39 | <li><code>NumberLibraryNearRings( </code><var>G</var><code> )</code> | |
| 40 | <p> | |
| 41 | <a name = "SSEC001.3"></a> | |
| 42 | <li><code>AllLibraryNearRings( </code><var>G</var><code> )</code> | |
| 43 | <p> | |
| 44 | returns a list of all nearrings (in the library) that have the group <var>G</var> as | |
| 45 | group reduct. | |
| 46 | <p> | |
| 47 | <pre> | |
| 48 | gap> l := AllLibraryNearRings( GTW3_1 ); | |
| 49 | [ LibraryNearRing(3/1, 1), LibraryNearRing(3/1, 2), | |
| 50 | LibraryNearRing(3/1, 3), LibraryNearRing(3/1, 4), | |
| 51 | LibraryNearRing(3/1, 5) ] | |
| 52 | gap> Filtered( l, IsNearField ); | |
| 53 | [ LibraryNearRing(3/1, 3) ] | |
| 54 | gap> NumberLibraryNearRings( GTW14_2 ); | |
| 55 | 1821 | |
| 56 | gap> LN14_2_1234 := LibraryNearRing( GTW14_2, 1234 ); | |
| 57 | LibraryNearRing(14/2, 1234) | |
| 58 | </pre> | |
| 59 | <p> | |
| 60 | <a name = "SSEC001.4"></a> | |
| 61 | <li><code>LibraryNearRingWithOne( </code><var>G</var><code>, </code><var>num</var><code> )</code> | |
| 62 | <p> | |
| 63 | <code>LibraryNearRingWithOne</code> retrieves a nearring from the nearrings library | |
| 64 | files. | |
| 65 | <var>G</var> must be one of the predefined groups of order <font face="symbol">£</font> 31. | |
| 66 | <var>num</var> must be an integer which indicates the number of the class of | |
| 67 | nearrings with identity on the specified group. | |
| 68 | <p> | |
| 69 | The number of nearrings with identity definable on a certain group <var>G</var> | |
| 70 | can be accessed via | |
| 71 | <p> | |
| 72 | <a name = "SSEC001.5"></a> | |
| 73 | <li><code>NumberLibraryNearRingsWithOne( </code><var>G</var><code> )</code> | |
| 74 | <p> | |
| 75 | <a name = "SSEC001.6"></a> | |
| 76 | <li><code>AllLibraryNearRingsWithOne( </code><var>G</var><code> )</code> | |
| 77 | <p> | |
| 78 | returns a list of all nearrings with identity (in the library) that have | |
| 79 | the group <var>G</var> as group reduct. | |
| 80 | <p> | |
| 81 | <pre> | |
| 82 | gap> NumberLibraryNearRingsWithOne( GTW24_6 ); | |
| 83 | 0 | |
| 84 | gap> NumberLibraryNearRingsWithOne( GTW24_4 ); | |
| 85 | 10 | |
| 86 | gap> LNwI24_4_8 := LibraryNearRingWithOne( GTW24_4, 8 ); | |
| 87 | LibraryNearRingWithOne(24/4, 8) | |
| 88 | gap> AllLibraryNearRingsWithOne( GTW24_6 ); | |
| 89 | [ ] | |
| 90 | </pre> | |
| 91 | <p> | |
| 92 | <p> | |
| 93 | <h2><a name="SECT002">3.2 Identifying nearrings</a></h2> | |
| 94 | <p><p> | |
| 95 | <a name = "SSEC002.1"></a> | |
| 96 | <li><code>IdLibraryNearRing( </code><var>nr</var><code> )</code> | |
| 97 | <p> | |
| 98 | The function <code>IdLibraryNearRing</code> returns a pair [<i>G</i>, <i>n</i>] such that the | |
| 99 | nearring <var>nr</var> is isomorphic to the <i>n</i>th library nearring on the group <i>G</i>. | |
| 100 | <p> | |
| 101 | <pre> | |
| 102 | gap> p := PolynomialNearRing( GTW4_2 ); | |
| 103 | PolynomialNearRing( 4/2 ) | |
| 104 | gap> IdLibraryNearRing( p ); | |
| 105 | [ 8/3, 833 ] | |
| 106 | gap> n := LibraryNearRing( GTW3_1, 4 ); | |
| 107 | LibraryNearRing(3/1, 4) | |
| 108 | gap> d := DirectProductNearRing( n, n ); | |
| 109 | DirectProductNearRing( LibraryNearRing(3/1, 4), LibraryNearRing(3/1, 4)\ | |
| 110 | ) | |
| 111 | gap> IdLibraryNearRing( d ); | |
| 112 | [ 9/2, 220 ] | |
| 113 | </pre> | |
| 114 | <p> | |
| 115 | <a name = "SSEC002.2"></a> | |
| 116 | <li><code>IdLibraryNearRingWithOne( </code><var>nr</var><code> )</code> | |
| 117 | <p> | |
| 118 | The function <code>IdLibraryNearRingWithOne</code> returns a pair [<i>G</i>, <i>n</i>] such | |
| 119 | that the nearring <var>nr</var> is isomorphic to the <i>n</i>th library nearring with | |
| 120 | identity on the group <i>G</i>. This function can only be applied to nearrings | |
| 121 | which have an identity. | |
| 122 | <p> | |
| 123 | <pre> | |
| 124 | gap> l := LibraryNearRingWithOne( GTW12_3, 1 ); | |
| 125 | LibraryNearRingWithOne(12/3, 1) | |
| 126 | gap> IdLibraryNearRing( l ); #this command requires time and memory!!! | |
| 127 | [ 12/3, 37984 ] | |
| 128 | gap> IdLibraryNearRingWithOne( l ); | |
| 129 | [ 12/3, 1 ] | |
| 130 | </pre> | |
| 131 | <p> | |
| 132 | <p> | |
| 133 | <h2><a name="SECT003">3.3 IsLibraryNearRing</a></h2> | |
| 134 | <p><p> | |
| 135 | <a name = "SSEC003.1"></a> | |
| 136 | <li><code>IsLibraryNearRing( </code><var>nr</var><code> )</code> | |
| 137 | <p> | |
| 138 | The function <code>IsLibraryNearRing</code> returns <code>true</code> if the nearring <var>nr</var> has been | |
| 139 | read from the nearring library and <code>false</code> otherwise. | |
| 140 | <p> | |
| 141 | <pre> | |
| 142 | gap> IsLibraryNearRing( LNwI24_4_8 ); | |
| 143 | true | |
| 144 | </pre> | |
| 145 | <p> | |
| 146 | <p> | |
| 147 | <h2><a name="SECT004">3.4 Accessing the information about a nearring stored in the library</a></h2> | |
| 148 | <p><p> | |
| 149 | <a name = "SSEC004.1"></a> | |
| 150 | <li><code>LibraryNearRingInfo( </code><var>group</var><code>, </code><var>list</var><code>, </code><var>string</var><code> )</code> | |
| 151 | <p> | |
| 152 | This function provides information about the specified library nearrings | |
| 153 | in a way similar to how nearrings are presented in the appendix of | |
| 154 | [Pil??]. | |
| 155 | The parameter <var>group</var> specifies a predefined group; valid | |
| 156 | names are exactly those which are also valid for the function | |
| 157 | <code>LibraryNearrings</code> (cf. Section <a href="CHAP003.htm#SSEC001.1">LibraryNearRing</a>). | |
| 158 | <p> | |
| 159 | The parameter <var>list</var> must be a non-empty list of integers defining the | |
| 160 | classes of nearrings to be printed. Naturally, these integers must all fit | |
| 161 | into the ranges described in Section <a href="CHAP003.htm#SSEC001.1">LibraryNearRing</a> for the according | |
| 162 | groups. | |
| 163 | <p> | |
| 164 | The third parameter <var>string</var> is optional. <var>string</var> must be a string | |
| 165 | consisting of one or more (or all) of the following characters: | |
| 166 | <code>l</code>, <code>m</code>, <code>i</code>, <code>v</code>, <code>s</code>, <code>e</code>, <code>a</code>. | |
| 167 | Per default, (i.e. if this parameter is not specified), the output is | |
| 168 | minimal. According to each specified character, the following is added: | |
| 169 | <p> | |
| 170 | <dl compact> | |
| 171 | <dt> <code>a</code> <dd> list the nearring automorphisms. | |
| 172 | <p> | |
| 173 | <dt> <code>c</code> <dd> print the meaning of the letters used in the output. | |
| 174 | <p> | |
| 175 | <dt> <code>e</code> <dd> list the nearring endomorphisms. | |
| 176 | <p> | |
| 177 | <dt> <code>g</code> <dd> list the endomorphisms of the group reduct. | |
| 178 | <p> | |
| 179 | <dt> <code>i</code> <dd> list the ideals. | |
| 180 | <p> | |
| 181 | <dt> <code>l</code> <dd> list the left ideals. | |
| 182 | <p> | |
| 183 | <dt> <code>m</code> <dd> print the multiplication tables. | |
| 184 | <p> | |
| 185 | <dt> <code>r</code> <dd> list the right ideals. | |
| 186 | <p> | |
| 187 | <dt> <code>s</code> <dd> list the subnearrings. | |
| 188 | <p> | |
| 189 | <dt> <code>v</code> <dd> list the invariant subnearrings. | |
| 190 | <p> | |
| 191 | </dl> | |
| 192 | <p> | |
| 193 | <strong>Examples:</strong> | |
| 194 | <p> | |
| 195 | <code>LibraryNearRingInfo( GTW3_1, [ 3 ], "lmivsea" )</code> will print all | |
| 196 | available information about the third class of nearrings on the group | |
| 197 | <i>Z</i><sub>3</sub>. | |
| 198 | <p> | |
| 199 | <code>LibraryNearRingInfo( GTW4_1, [ 1..12 ] )</code> will provide a minimal output | |
| 200 | for all classes of nearrings on <i>Z</i><sub>4</sub>. | |
| 201 | <p> | |
| 202 | <code>LibraryNearRingInfo( GTW6_2, [ 5, 18, 21 ], "mi" )</code> will print | |
| 203 | the minimal information plus the multiplication tables plus the ideals for | |
| 204 | the classes 5, 18, and 21 of nearrings on the group <i>S</i><sub>3</sub>. | |
| 205 | <p> | |
| 206 | <p> | |
| 207 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Previous</a>] [<a href ="CHAP004.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 208 | <P> | |
| 209 | <address>SONATA manual<br>October 2018 | |
| 210 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 4 Arbitrary functions on groups: EndoMappings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>4 Arbitrary functions on groups: EndoMappings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP004.htm#SECT001">Defining endo mappings</a> | |
| 8 | <li> <A HREF="CHAP004.htm#SECT002">Properties of endo mappings</a> | |
| 9 | <li> <A HREF="CHAP004.htm#SECT003">Operations for endo mappings</a> | |
| 10 | <li> <A HREF="CHAP004.htm#SECT004">Nicer ways to print a mapping</a> | |
| 11 | </ol><p> | |
| 12 | <p> | |
| 13 | An <strong>endomapping</strong> is a mapping with equal source and range, say <i>G</i>, | |
| 14 | where <i>G</i> is a group. An endomapping on <i>G</i> then acts on <i>G</i> by | |
| 15 | <strong>transforming</strong> each element of <i>G</i> into (precisely one) element of <i>G</i>. | |
| 16 | Endomappings are special cases of Mappings. | |
| 17 | <p> | |
| 18 | Endomappings are created by the constructor functions | |
| 19 | <code>EndoMappingByPositionList</code>, <code>EndoMappingByFunction</code>, <code>IdentityEndoMapping</code>, | |
| 20 | <code>ConstantEndoMapping</code>, and are represented as mappings. | |
| 21 | The functions described in | |
| 22 | this section can be found in the file <code>grptfms.g?</code>. | |
| 23 | <p> | |
| 24 | <p> | |
| 25 | <h2><a name="SECT001">4.1 Defining endo mappings</a></h2> | |
| 26 | <p><p> | |
| 27 | <a name = "SSEC001.1"></a> | |
| 28 | <li><code>EndoMappingByPositionList ( </code><var>G</var><code>, </code><var>list</var><code> )</code> | |
| 29 | <p> | |
| 30 | The constructor function <code>EndoMappingByPositionList</code> returns the | |
| 31 | the endomapping that maps the i-th element of the group (in the | |
| 32 | ordering given by AsSortedList) | |
| 33 | to the i-th element of list. | |
| 34 | <p> | |
| 35 | <pre> | |
| 36 | gap> G := GTW4_2; | |
| 37 | 4/2 | |
| 38 | gap> t1 := EndoMappingByPositionList ( G, [1, 2, 4, 4] ); | |
| 39 | <mapping: 4/2 -> 4/2 > | |
| 40 | </pre> | |
| 41 | <p> | |
| 42 | <a name = "SSEC001.2"></a> | |
| 43 | <li><code>EndoMappingByFunction( </code><var>G</var><code>, </code><var>fun</var><code> )</code> | |
| 44 | <p> | |
| 45 | The constructor function <code>EndoMappingByFunction</code> returns the | |
| 46 | function <var>fun</var> that maps elements of the group <var>G</var> into <var>G</var> as an | |
| 47 | endomapping. | |
| 48 | <p> | |
| 49 | <pre> | |
| 50 | gap> t2 := EndoMappingByFunction ( GTW8_2, g -> g^-1 ); | |
| 51 | <mapping: 8/2 -> 8/2 > | |
| 52 | gap> IsGroupHomomorphism ( t2 ); | |
| 53 | true | |
| 54 | gap> t3 := EndoMappingByFunction ( GTW6_2, g -> g^-1 ); | |
| 55 | <mapping: 6/2 -> 6/2 > | |
| 56 | gap> IsGroupHomomorphism ( t3 ); | |
| 57 | false | |
| 58 | </pre> | |
| 59 | <p> | |
| 60 | <code>EndoMappings</code> and <code>GroupGeneralMappings</code> are different | |
| 61 | kinds of objects in <font face="Gill Sans,Helvetica,Arial">GAP</font>: <code>GroupGeneralMappings</code> model homomorphisms between | |
| 62 | two different groups, whereas <code>EndoMappings</code> model nonlinear functions | |
| 63 | on one group. | |
| 64 | However, <code>GroupGeneralMappings</code> can be transformed into | |
| 65 | <code>Endomappings</code> if they have equal source and range. | |
| 66 | <p> | |
| 67 | <a name = "SSEC001.3"></a> | |
| 68 | <li><code>AsEndoMapping( </code><var>map</var><code> )</code> | |
| 69 | <p> | |
| 70 | The constructor function <code>AsEndoMapping</code> returns the mapping <var>map</var> | |
| 71 | as an endomapping. | |
| 72 | <p> | |
| 73 | <pre> | |
| 74 | gap> G1 := Group ((1,2,3), (1, 2)); | |
| 75 | Group([ (1,2,3), (1,2) ]) | |
| 76 | gap> G2 := Group ((2,3,4), (2, 3)); | |
| 77 | Group([ (2,3,4), (2,3) ]) | |
| 78 | gap> f1 := IsomorphismGroups ( G1, G2 ); | |
| 79 | [ (1,2,3), (1,2) ] -> [ (2,3,4), (2,3) ] | |
| 80 | gap> f2 := IsomorphismGroups ( G2, G1 ); | |
| 81 | [ (2,3,4), (2,3) ] -> [ (1,2,3), (1,2) ] | |
| 82 | gap> AsEndoMapping ( CompositionMapping ( f1, f2 ) ); | |
| 83 | <mapping: Group( [ (2,3,4), (2,3) ] ) -> Group( [ (2,3,4), (2,3) | |
| 84 | ] ) > | |
| 85 | </pre> | |
| 86 | <p> | |
| 87 | <code>EndoMappings</code> and <code>GroupGeneralMappings</code> are two completely different | |
| 88 | kinds of objects in <font face="Gill Sans,Helvetica,Arial">GAP</font>, but they can be transformed into one | |
| 89 | another. | |
| 90 | <p> | |
| 91 | <a name = "SSEC001.4"></a> | |
| 92 | <li><code>AsGroupGeneralMappingByImages( </code><var>endomap</var><code> )</code> | |
| 93 | <p> | |
| 94 | <code>AsGroupGeneralMappingByImages</code> returns the | |
| 95 | <code>GroupGeneralMappingByImages</code> that acts on the group the same way as | |
| 96 | the endomapping <var>endomap</var>. It only makes sense to use this function | |
| 97 | for endomappings that are group endomorphisms. | |
| 98 | <p> | |
| 99 | <pre> | |
| 100 | gap> m := IdentityEndoMapping ( GTW6_2 ); | |
| 101 | <mapping: 6/2 -> 6/2 > | |
| 102 | gap> AsGroupGeneralMappingByImages ( m ); | |
| 103 | [ (1,2), (1,2,3) ] -> [ (1,2), (1,2,3) ] | |
| 104 | </pre> | |
| 105 | <p> | |
| 106 | <a name = "SSEC001.5"></a> | |
| 107 | <li><code>IsEndoMapping( </code><var>obj</var><code> )</code> | |
| 108 | <p> | |
| 109 | <code>IsEndoMapping</code> returns <code>true</code> if the object <var>obj</var> is an endomapping | |
| 110 | and <code>false</code> otherwise. | |
| 111 | <p> | |
| 112 | <pre> | |
| 113 | gap> IsEndoMapping ( InnerAutomorphisms ( GTW6_2 ) [3] ); | |
| 114 | true | |
| 115 | </pre> | |
| 116 | <p> | |
| 117 | <a name = "SSEC001.6"></a> | |
| 118 | <li><code>IdentityEndoMapping( </code><var>G</var><code> )</code> | |
| 119 | <p> | |
| 120 | <code>IdentitEndoMapping</code> is the counterpart to the <font face="Gill Sans,Helvetica,Arial">GAP</font> standard | |
| 121 | library function <code>IdentityMapping</code>. It returns the identity | |
| 122 | transformation on the group <var>G</var>. | |
| 123 | <p> | |
| 124 | <pre> | |
| 125 | gap> AsList ( UnderlyingRelation ( IdentityEndoMapping ( Group ((1,2,3,4)) ) ) ); | |
| 126 | [ Tuple( [ (), () ] ), Tuple( [ (1,2,3,4), (1,2,3,4) ] ), | |
| 127 | Tuple( [ (1,3)(2,4), (1,3)(2,4) ] ), Tuple( [ (1,4,3,2), (1,4,3,2) ] ) | |
| 128 | ] | |
| 129 | </pre> | |
| 130 | <p> | |
| 131 | <a name = "SSEC001.7"></a> | |
| 132 | <li><code>ConstantEndoMapping( </code><var>G</var><code>, </code><var>g</var><code> )</code> | |
| 133 | <p> | |
| 134 | <code>ConstantEndoMapping</code> returns the endomapping on the group <var>G</var> | |
| 135 | which maps everything to the group element <var>g</var> of <var>G</var>. | |
| 136 | <p> | |
| 137 | <pre> | |
| 138 | gap> C3 := CyclicGroup (3); | |
| 139 | <pc group of size 3 with 1 generators> | |
| 140 | gap> m := ConstantEndoMapping (C3, AsSortedList (C3) [2]); | |
| 141 | MappingByFunction( <pc group of size 3 with | |
| 142 | 1 generators>, <pc group of size 3 with | |
| 143 | 1 generators>, function( x ) ... end ) | |
| 144 | gap> List (AsList (C3), x -> Image (m, x)); | |
| 145 | [ f1, f1, f1 ] | |
| 146 | </pre> | |
| 147 | <p> | |
| 148 | <p> | |
| 149 | <h2><a name="SECT002">4.2 Properties of endo mappings</a></h2> | |
| 150 | <p><p> | |
| 151 | <a name = "SSEC002.1"></a> | |
| 152 | <li><code>IsIdentityEndoMapping( </code><var>endomap</var><code> )</code> | |
| 153 | <p> | |
| 154 | <code>IsIdentityEndoMapping</code> returns <code>true</code> if <var>endomap</var> is the identity | |
| 155 | function on a group. | |
| 156 | <p> | |
| 157 | <pre> | |
| 158 | gap> IsIdentityEndoMapping (EndoMappingByFunction ( | |
| 159 | > AlternatingGroup ( [1..5] ), x -> x^31)); | |
| 160 | true | |
| 161 | </pre> | |
| 162 | <p> | |
| 163 | <a name = "SSEC002.2"></a> | |
| 164 | <li><code>IsConstantEndoMapping( </code><var>endomap</var><code> )</code> | |
| 165 | <p> | |
| 166 | <code>IsConstantEndoMapping</code> returns <code>true</code> if the endomapping | |
| 167 | <var>endomap</var> is constant and <code>false</code> otherwise. | |
| 168 | <p> | |
| 169 | <pre> | |
| 170 | gap> C3 := CyclicGroup ( 3 ); | |
| 171 | <pc group of size 3 with 1 generators> | |
| 172 | gap> IsConstantEndoMapping ( EndoMappingByFunction ( C3, x -> x^3 )); | |
| 173 | true | |
| 174 | </pre> | |
| 175 | <p> | |
| 176 | <a name = "SSEC002.3"></a> | |
| 177 | <li><code>IsDistributiveEndoMapping( </code><var>endomap</var><code> )</code> | |
| 178 | <p> | |
| 179 | A mapping <i>t</i> on an (additively written) group <i>G</i> is called | |
| 180 | <strong>distributive</strong> if for all elements <i>x</i> and <i>y</i> in <i>G</i>:\ | |
| 181 | <i>t</i>(<i>x</i>+<i>y</i>) = <i>t</i>(<i>x</i>) + <i>t</i>(<i>y</i>). | |
| 182 | The function <code>IsDistributiveEndoMapping</code> returns the according | |
| 183 | boolean value <code>true</code> or <code>false</code>. | |
| 184 | <p> | |
| 185 | <pre> | |
| 186 | gap> G := Group ( (1,2,3), (1,2) ); | |
| 187 | Group([ (1,2,3), (1,2) ]) | |
| 188 | gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^3)); | |
| 189 | false | |
| 190 | gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^7)); | |
| 191 | true | |
| 192 | </pre> | |
| 193 | <p> | |
| 194 | <p> | |
| 195 | <h2><a name="SECT003">4.3 Operations for endo mappings</a></h2> | |
| 196 | <p><p> | |
| 197 | While the composition operator <code>*</code> is applicable to mappings and | |
| 198 | transformations, the operation <code>+</code> (pointwise addition of the images) can | |
| 199 | only be applied to transformations. | |
| 200 | <p> | |
| 201 | The product operator <code>*</code> returns the transformation which is obtained | |
| 202 | from the transformations <var>t1</var> and <var>t2</var> by composition of <var>t1</var> and <var>t2</var> | |
| 203 | (i.e. performing <var>t2</var> <strong>after</strong> <var>t1</var>). | |
| 204 | <p> | |
| 205 | <pre> | |
| 206 | gap> t1 := ConstantEndoMapping ( GTW2_1, ()); | |
| 207 | MappingByFunction( 2/1, 2/1, function( x ) ... end ) | |
| 208 | gap> t2 := ConstantEndoMapping (GTW2_1, (1, 2)); | |
| 209 | MappingByFunction( 2/1, 2/1, function( x ) ... end ) | |
| 210 | gap> List ( AsList ( GTW2_1 ), x -> Image ( t1 * t2, x )); | |
| 211 | [ (1,2), (1,2) ] | |
| 212 | </pre> | |
| 213 | <p> | |
| 214 | The add operator <code>+</code> returns the endomapping which is obtained | |
| 215 | from the endomappings <var>t1</var> and <var>t2</var> by pointwise addition | |
| 216 | of <var>t1</var> and <var>t2</var>. (Note that in this context addition means that | |
| 217 | for every place <i>x</i> in the source of <var>t1</var> and <var>t2</var>, | |
| 218 | <font face="Gill Sans,Helvetica,Arial">GAP</font> performs the operation <code>p * q</code>, where | |
| 219 | <code>p</code> is the image of <var>t1</var> at <i>x</i> and <code>q</code> is the image of <var>t2</var> at <i>x</i>.) | |
| 220 | <p> | |
| 221 | The subtract operator <code>-</code> returns the endomapping which is | |
| 222 | obtained from the endomappings <var>t1</var> and <var>t2</var> by pointwise | |
| 223 | subtraction of <var>t1</var> and <var>t2</var>. (Note that in this context subtraction | |
| 224 | means performing the <font face="Gill Sans,Helvetica,Arial">GAP</font> operation <code>p * q^(-1)</code>, | |
| 225 | where | |
| 226 | <code>p</code> is the image of <var>t1</var> at a place <i>x</i> and <code>q</code> is the image of <var>t2</var> at <i>x</i>.) | |
| 227 | <p> | |
| 228 | <pre> | |
| 229 | gap> G := SymmetricGroup ( 3 ); | |
| 230 | Sym( [ 1 .. 3 ] ) | |
| 231 | gap> invertingOnG := EndoMappingByFunction ( G, x -> x^-1 ); | |
| 232 | <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( | |
| 233 | [ 1 .. 3 ] ) > | |
| 234 | gap> identityOnG := IdentityEndoMapping (G); | |
| 235 | <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( | |
| 236 | [ 1 .. 3 ] ) > | |
| 237 | gap> AsSortedList ( G ); | |
| 238 | [ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ] | |
| 239 | gap> List ( AsSortedList (G), | |
| 240 | > x -> Image ( identityOnG * invertingOnG, x )); | |
| 241 | [ (), (2,3), (1,2), (1,3,2), (1,2,3), (1,3) ] | |
| 242 | gap> List ( AsSortedList (G), | |
| 243 | > x -> Image ( identityOnG + invertingOnG, x )); | |
| 244 | [ (), (), (), (), (), () ] | |
| 245 | gap> IsIdentityEndoMapping ( - invertingOnG ); | |
| 246 | true | |
| 247 | gap> - invertingOnG = identityOnG; | |
| 248 | true | |
| 249 | </pre> | |
| 250 | <p> | |
| 251 | <p> | |
| 252 | <h2><a name="SECT004">4.4 Nicer ways to print a mapping</a></h2> | |
| 253 | <p><p> | |
| 254 | <a name = "SSEC004.1"></a> | |
| 255 | <li><code>GraphOfMapping( </code><var>mapping</var><code> )</code> | |
| 256 | <p> | |
| 257 | <code>GraphOfMapping</code> returns the set of all pairs (x,m(x)), where | |
| 258 | x lies in the source of the mapping. In particular, it returns | |
| 259 | List (Source (m), x -> [x, Image (m, x)]); | |
| 260 | <p> | |
| 261 | <pre> | |
| 262 | gap> G := SymmetricGroup ( 3 ); | |
| 263 | Sym( [ 1 .. 3 ] ) | |
| 264 | gap> m := ConstantEndoMapping (G, (1,2,3)) + IdentityEndoMapping( G ); | |
| 265 | MappingByFunction( Sym( [ 1 .. 3 ] ), Sym( [ 1 .. 3 ] ), function( g ) ... end ) | |
| 266 | gap> PrintArray( GraphOfMapping( m ) ); | |
| 267 | [ [ (), (1,2,3) ], | |
| 268 | [ (2,3), (1,3) ], | |
| 269 | [ (1,2), (2,3) ], | |
| 270 | [ (1,2,3), (1,3,2) ], | |
| 271 | [ (1,3,2), () ], | |
| 272 | [ (1,3), (1,2) ] ] | |
| 273 | </pre> | |
| 274 | <p> | |
| 275 | <a name = "SSEC004.2"></a> | |
| 276 | <li><code>PrintAsTerm( </code><var>mapping</var><code> )</code> | |
| 277 | <p> | |
| 278 | If <var>mapping</var> is a polynomial function on its source then <code>PrintAsTerm</code> | |
| 279 | prints a polynomial that induces the mapping <var>mapping</var>. | |
| 280 | <pre> | |
| 281 | gap> G := SymmetricGroup ( 3 ); | |
| 282 | Sym( [ 1 .. 3 ] ) | |
| 283 | gap> p := Random( PolynomialNearRing( G ) ); | |
| 284 | <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( [ 1 .. 3 ] ) > | |
| 285 | gap> PrintAsTerm( p ); | |
| 286 | g1 - x - 2 * g1 - g2 - x - g1 - g2 + g1 - x - 2 * g1 - | |
| 287 | g2 - x - g1 - g2 - 3 * x + g1 | |
| 288 | gap> GeneratorsOfGroup( G ); | |
| 289 | [ (1,2,3), (1,2) ] | |
| 290 | </pre> | |
| 291 | <p> | |
| 292 | The expressions <code>g1</code> and <code>g2</code> stand for the first and secong generator | |
| 293 | of the group <var>G</var> respectively. The result is not necessarily a | |
| 294 | polynomial of minimal length. | |
| 295 | <p> | |
| 296 | <p> | |
| 297 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 298 | <P> | |
| 299 | <address>SONATA manual<br>October 2018 | |
| 300 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 5 Transformation nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP004.htm">Previous</a>] [<a href ="CHAP006.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>5 Transformation nearrings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP005.htm#SECT001">Constructing transformation nearrings</a> | |
| 8 | <li> <A HREF="CHAP005.htm#SECT002">Nearrings of transformations</a> | |
| 9 | <li> <A HREF="CHAP005.htm#SECT003">The group a transformation nearring acts on</a> | |
| 10 | <li> <A HREF="CHAP005.htm#SECT004">Transformation nearrings and other nearrings</a> | |
| 11 | <li> <A HREF="CHAP005.htm#SECT005">Noetherian quotients for transformation nearrings</a> | |
| 12 | <li> <A HREF="CHAP005.htm#SECT006">Zerosymmetric mappings</a> | |
| 13 | </ol><p> | |
| 14 | <p> | |
| 15 | In the previous chapter we introduced mappings on groups, and we | |
| 16 | called them <strong>endomappings</strong>. We also introduced the operation of | |
| 17 | pointwise addition <code>+</code> for endomappings. Now we are able to use these | |
| 18 | mappings together with pointwise addition <code>+</code> and composition <code>*</code> to | |
| 19 | construct left nearrings. These nearrings satisfy the distributive | |
| 20 | law <i>x</i> * (<i>y</i> + <i>z</i>) = <i>x</i> * <i>y</i> + <i>x</i> * <i>z</i>. | |
| 21 | <p> | |
| 22 | A <strong>transformation nearring</strong> is a set of mappings on a group <i>G</i> that | |
| 23 | is closed under pointwise addition of mappings, under forming the | |
| 24 | additive inverse and under functional composition. For more | |
| 25 | information we suggest <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>], <a href="biblio.htm#meldrum85:NATLWG"><[>meldrum85:NATLWG</cite></a>], | |
| 26 | and <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>], | |
| 27 | <p> | |
| 28 | The algorithms used can be found in | |
| 29 | <a href="biblio.htm#aichingereckernoebauer00:TUOCINT"><[>aichingereckernoebauer00:TUOCINT</cite></a>] and <a href="biblio.htm#aichingerea00:CWN"><[>aichingerea00:CWN</cite></a>]. | |
| 30 | <p> | |
| 31 | The elements of a transformation nearring are given as endomappings on | |
| 32 | the group <i>G</i> (cf. Chapter ``Functions on groups that are not | |
| 33 | necessarily homomorphisms: EndoMappings''). | |
| 34 | <p> | |
| 35 | <p> | |
| 36 | <h2><a name="SECT001">5.1 Constructing transformation nearrings</a></h2> | |
| 37 | <p><p> | |
| 38 | <a name = "SSEC001.1"></a> | |
| 39 | <li><code>TransformationNearRingByGenerators( </code><var>G</var><code>, </code><var>endomaplist</var><code> )</code> | |
| 40 | <p> | |
| 41 | For a (possibly empty) list <var>endomaplist</var> of endomappings on a group | |
| 42 | <var>G</var>, the constructor function <code>TransformationNearRingByGenerators</code> returns the | |
| 43 | nearring generated by these mappings. All of them must be | |
| 44 | endomappings on the group <var>G</var>. | |
| 45 | <p> | |
| 46 | <pre> | |
| 47 | gap> g := AlternatingGroup ( 4 ); | |
| 48 | Alt( [ 1 .. 4 ] ) | |
| 49 | gap> AsSortedList ( g ); | |
| 50 | [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), | |
| 51 | (1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ] | |
| 52 | gap> t := EndoMappingByPositionList ( g, [1,3,4,5,2,1,1,1,1,1,1,1] ); | |
| 53 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 54 | [ 1 .. 4 ] ) > | |
| 55 | gap> m := TransformationNearRingByGenerators ( g, [t] ); | |
| 56 | TransformationNearRingByGenerators( | |
| 57 | [ <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 58 | [ 1 .. 4 ] ) > ]) | |
| 59 | gap> Size (m); # may take a few moments | |
| 60 | 20736 | |
| 61 | gap> IsCommutative ( m ); | |
| 62 | false | |
| 63 | </pre> | |
| 64 | <p> | |
| 65 | <a name = "SSEC001.2"></a> | |
| 66 | <li><code>TransformationNearRingByAdditiveGenerators( </code><var>G</var><code>, </code><var>endomaplist</var><code> )</code> | |
| 67 | <p> | |
| 68 | If a transformation nearring is known to be additively generated by a | |
| 69 | set of endomappings on a group (as for example the distributively | |
| 70 | generated nearrings <i>E</i>(<i>G</i>), <i>A</i>(<i>G</i>) and <i>I</i>(<i>G</i>)), the function | |
| 71 | <code>TransformationNearRingByAdditiveGenerators</code> allows to | |
| 72 | construct this nearring. The only difference between | |
| 73 | <code>TransformationNearRingByGenerators</code> and | |
| 74 | <code>TransformationNearRingByAdditiveGenerators</code> is that | |
| 75 | <code>TransformationNearRingByAdditiveGenerators</code> is much faster. | |
| 76 | <p> | |
| 77 | <pre> | |
| 78 | gap> G := SymmetricGroup(3);; | |
| 79 | gap> endos := Endomorphisms ( G ); | |
| 80 | [ [ (1,2,3), (1,2) ] -> [ (), () ], [ (1,2,3), (1,2) ] -> [ (), (2,3) ], | |
| 81 | [ (1,2,3), (1,2) ] -> [ (), (1,2) ], [ (1,2,3), (1,2) ] -> [ (), (1,3) ], | |
| 82 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (2,3) ], | |
| 83 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (2,3) ], | |
| 84 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,2) ], | |
| 85 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,2) ], | |
| 86 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,3) ], | |
| 87 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,3) ] ] | |
| 88 | gap> Endo := TransformationNearRingByAdditiveGenerators ( G, endos ); | |
| 89 | < transformation nearring with 10 generators > | |
| 90 | gap> Size( Endo ); | |
| 91 | 54 | |
| 92 | </pre> | |
| 93 | <p> | |
| 94 | <p> | |
| 95 | <h2><a name="SECT002">5.2 Nearrings of transformations</a></h2> | |
| 96 | <p><p> | |
| 97 | <a name = "SSEC002.1"></a> | |
| 98 | <li><code>MapNearRing( </code><var>G</var><code> )</code> | |
| 99 | <p> | |
| 100 | <a name = "SSEC002.2"></a> | |
| 101 | <li><code>TransformationNearRing( </code><var>G</var><code> )</code> | |
| 102 | <p> | |
| 103 | <code>MapNearRing</code> and <code>TransformationNearRing</code> both return the nearring of all | |
| 104 | mappings on <var>G</var>. | |
| 105 | <p> | |
| 106 | <pre> | |
| 107 | gap> m := MapNearRing ( GTW32_12 ); | |
| 108 | TransformationNearRing(32/12) | |
| 109 | gap> Size ( m ); | |
| 110 | 1461501637330902918203684832716283019655932542976 | |
| 111 | gap> NearRingIdeals ( m ); | |
| 112 | [ < nearring ideal >, < nearring ideal > ] | |
| 113 | </pre> | |
| 114 | <p> | |
| 115 | <a name = "SSEC002.3"></a> | |
| 116 | <li><code>IsFullTransformationNearRing( </code><var>tfmnr</var><code> )</code> | |
| 117 | <p> | |
| 118 | The function <code>IsFullTransformationNearRing</code> returns <code>true</code> if the | |
| 119 | transformation nearring <var>tfmnr</var> is the nearring of all mappings over | |
| 120 | the group. | |
| 121 | <p> | |
| 122 | <pre> | |
| 123 | gap> g := CyclicGroup ( 4 ); | |
| 124 | <pc group of size 4 with 2 generators> | |
| 125 | gap> m := MapNearRing ( g ); | |
| 126 | TransformationNearRing(<pc group of size 4 with 2 generators>) | |
| 127 | gap> gens := Filtered ( AsList ( m ), | |
| 128 | > f -> IsFullTransformationNearRing ( | |
| 129 | > TransformationNearRingByGenerators ( g, [ f ] )));; | |
| 130 | gap> Length(gens); | |
| 131 | 12 | |
| 132 | </pre> | |
| 133 | <p> | |
| 134 | <a name = "SSEC002.4"></a> | |
| 135 | <li><code>PolynomialNearRing( </code><var>G</var><code> )</code> | |
| 136 | <p> | |
| 137 | <code>PolynomialNearRing</code> returns the nearring of all polynomial functions on <var>G</var>. | |
| 138 | <p> | |
| 139 | <pre> | |
| 140 | gap> P := PolynomialNearRing ( GTW16_6 ); | |
| 141 | PolynomialNearRing( 16/6 ) | |
| 142 | gap> Size ( P ); | |
| 143 | 256 | |
| 144 | </pre> | |
| 145 | <p> | |
| 146 | <a name = "SSEC002.5"></a> | |
| 147 | <li><code>EndomorphismNearRing( </code><var>G</var><code> )</code> | |
| 148 | <p> | |
| 149 | <code>EndomorphismNearRing</code> returns the nearring generated by all endomorphisms | |
| 150 | on <var>G</var>. | |
| 151 | <p> | |
| 152 | <pre> | |
| 153 | gap> ES4 := EndomorphismNearRing ( SymmetricGroup ( 4 ) ); | |
| 154 | EndomorphismNearRing( Sym( [ 1 .. 4 ] ) ) | |
| 155 | gap> Size ( ES4 ); | |
| 156 | 927712935936 | |
| 157 | </pre> | |
| 158 | <p> | |
| 159 | <a name = "SSEC002.6"></a> | |
| 160 | <li><code>AutomorphismNearRing( </code><var>G</var><code> )</code> | |
| 161 | <p> | |
| 162 | <code>AutomorphismNearRing</code> returns the nearring generated by all automorphisms | |
| 163 | on <var>G</var>. | |
| 164 | <p> | |
| 165 | <pre> | |
| 166 | gap> A := AutomorphismNearRing ( DihedralGroup ( 8 ) ); | |
| 167 | AutomorphismNearRing( <pc group of size 8 with 3 generators> ) | |
| 168 | gap> Length(NearRingRightIdeals ( A )); | |
| 169 | 28 | |
| 170 | gap> Size (A); | |
| 171 | 32 | |
| 172 | </pre> | |
| 173 | <p> | |
| 174 | <a name = "SSEC002.7"></a> | |
| 175 | <li><code>InnerAutomorphismNearRing( </code><var>G</var><code> )</code> | |
| 176 | <p> | |
| 177 | <code>InnerAutomorphismNearRing</code> returns the nearring generated by all inner | |
| 178 | automorphisms on <var>G</var>. | |
| 179 | <p> | |
| 180 | <pre> | |
| 181 | gap> I := InnerAutomorphismNearRing ( AlternatingGroup ( 4 ) ); | |
| 182 | InnerAutomorphismNearRing( Alt( [ 1 .. 4 ] ) ) | |
| 183 | gap> Size ( I ); | |
| 184 | 3072 | |
| 185 | gap> m := Enumerator( I )[1000]; | |
| 186 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( [ 1 .. 4 ] ) > | |
| 187 | gap> graph := List ( AsList ( AlternatingGroup ( 4 ) ), | |
| 188 | > x -> [x, Image (m, x)] ); | |
| 189 | [ [ (), () ], [ (2,3,4), (1,4)(2,3) ], [ (2,4,3), (1,4)(2,3) ], | |
| 190 | [ (1,2)(3,4), (1,2)(3,4) ], [ (1,2,3), (1,3)(2,4) ], | |
| 191 | [ (1,2,4), (1,4)(2,3) ], [ (1,3,2), (1,4)(2,3) ], [ (1,3,4), (1,2)(3,4) ], | |
| 192 | [ (1,3)(2,4), (1,3)(2,4) ], [ (1,4,2), () ], [ (1,4,3), (1,4)(2,3) ], | |
| 193 | [ (1,4)(2,3), (1,4)(2,3) ] ] | |
| 194 | </pre> | |
| 195 | <p> | |
| 196 | <a name = "SSEC002.8"></a> | |
| 197 | <li><code>CompatibleFunctionNearRing( </code><var>G</var><code> )</code> | |
| 198 | <p> | |
| 199 | <code>CompatibleFunctionNearRing</code> returns the nearring of all compatible functions | |
| 200 | on the group <var>G</var>. A function <i>m</i>:<i>G</i> <font face="symbol">®</font> <i>G</i> is compatible iff for every normal | |
| 201 | subgroup <i>N</i> of <i>G</i> and all <i>g</i>,<i>h</i> <font face="symbol">Î</font> <i>G</i> if <i>g</i> and <i>h</i> are in the same coset of <i>N</i> | |
| 202 | then their images under <i>m</i> are in the same coset of <i>G</i>. | |
| 203 | <p> | |
| 204 | <a name = "SSEC002.9"></a> | |
| 205 | <li><code>ZeroSymmetricCompatibleFunctionNearRing( </code><var>G</var><code> )</code> | |
| 206 | <p> | |
| 207 | <code>ZeroSymmetricCompatibleFunctionNearRing</code> returns the nearring of all zerosymmetric | |
| 208 | compatible functions on the group <var>G</var>. This function is also called by | |
| 209 | <code>CompatibleFunctionNearRing</code>. | |
| 210 | <p> | |
| 211 | <a name = "SSEC002.10"></a> | |
| 212 | <li><code>IsCompatibleEndoMapping( </code><var>m</var><code> )</code> | |
| 213 | <p> | |
| 214 | <code>IsCompatibleEndoMapping</code> returns <code>true</code> iff <var>m</var> is a compatible function on its | |
| 215 | source. | |
| 216 | <p> | |
| 217 | <a name = "SSEC002.11"></a> | |
| 218 | <li><code>Is1AffineComplete( </code><var>G</var><code> )</code> | |
| 219 | <p> | |
| 220 | A group <var>G</var> is called 1-affine complete, iff every compatible function on <var>G</var> is | |
| 221 | polynomial. <code>Is1AffineComplete</code> returns <code>true</code> iff <var>G</var> is 1-affine complete. | |
| 222 | <p> | |
| 223 | <a name = "SSEC002.12"></a> | |
| 224 | <li><code>CentralizerNearRing( </code><var>G</var><code>, </code><var>endos</var><code> )</code> | |
| 225 | <p> | |
| 226 | <code>CentralizerNearRing</code> returns the nearring of all functions | |
| 227 | <i>m</i>:<i>G</i> <font face="symbol">®</font> <i>G</i> such that for all endomorphisms <i>e</i> in <var>endos</var> the | |
| 228 | equality <i>m</i> <font face="symbol">°</font><i>e</i> = <i>e</i> <font face="symbol">°</font><i>m</i> holds. | |
| 229 | <p> | |
| 230 | <pre> | |
| 231 | gap> autos := Automorphisms ( GTW8_4 ); | |
| 232 | [ IdentityMapping( 8/4 ), ^(2,4), | |
| 233 | [ (1,2,3,4), (2,4) ] -> [ (1,4,3,2), (1,2)(3,4) ], | |
| 234 | [ (1,2,3,4), (2,4) ] -> [ (1,2,3,4), (1,2)(3,4) ], ^(1,4)(2,3), | |
| 235 | ^(1,2,3,4), [ (1,2,3,4), (2,4) ] -> [ (1,2,3,4), (1,4)(2,3) ], | |
| 236 | [ (1,4)(2,3), (1,4,3,2) ] -> [ (2,4), (1,2,3,4) ] ] | |
| 237 | gap> C := CentralizerNearRing ( GTW8_4, autos ); | |
| 238 | CentralizerNearRing( 8/4, ... ) | |
| 239 | gap> C0 := ZeroSymmetricPart ( C ); | |
| 240 | < transformation nearring with 4 generators > | |
| 241 | gap> Size ( C0 ); | |
| 242 | 32 | |
| 243 | gap> Is := NearRingIdeals ( C0 ); | |
| 244 | [ < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 245 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 246 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 247 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 248 | < nearring ideal > ] | |
| 249 | gap> List (Is, Size); | |
| 250 | [ 1, 2, 4, 2, 4, 8, 8, 16, 4, 8, 16, 16, 32 ] | |
| 251 | </pre> | |
| 252 | <p> | |
| 253 | <a name = "SSEC002.13"></a> | |
| 254 | <li><code>RestrictedEndomorphismNearRing( </code><var>G</var><code>, </code><var>U</var><code> )</code> | |
| 255 | <p> | |
| 256 | <code>RestrictedEndomorphismNearRing</code> returns the nearring generated by all | |
| 257 | endomorphisms <i>e</i> on <i>G</i> with <i>e</i>(<i>G</i>) <font face="symbol">Í</font> <i>U</i>. | |
| 258 | <p> | |
| 259 | <pre> | |
| 260 | gap> G := GTW16_8; | |
| 261 | 16/8 | |
| 262 | gap> U := First ( NormalSubgroups ( G ), | |
| 263 | > x -> Size (x) = 2 ); | |
| 264 | Group([ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) | |
| 265 | gap> HGU := RestrictedEndomorphismNearRing (G, U); | |
| 266 | RestrictedEndomorphismNearRing( 16/8, Group( | |
| 267 | [ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) ) | |
| 268 | gap> Size (HGU); | |
| 269 | 8 | |
| 270 | gap> IsDistributiveNearRing ( HGU ); | |
| 271 | true | |
| 272 | gap> Filtered ( AsList ( HGU), | |
| 273 | > x -> x = x * x ); | |
| 274 | [ <mapping: 16/8 -> 16/8 > ] | |
| 275 | </pre> | |
| 276 | <p> | |
| 277 | <a name = "SSEC002.14"></a> | |
| 278 | <li><code>LocalInterpolationNearRing( </code><var>tfmnr</var><code>, </code><var>m</var><code> )</code> | |
| 279 | <p> | |
| 280 | <code>LocalInterpolationNearRing</code> returns the nearring of all mappings on | |
| 281 | <i>G</i> that can be interpolated at any set of <i>m</i> places by a mapping in | |
| 282 | <var>tfmnr</var>, where <i>G</i> is the domain and codomain of the elements in | |
| 283 | <var>tfmnr</var>. | |
| 284 | <p> | |
| 285 | <pre> | |
| 286 | gap> P := PolynomialNearRing ( GTW8_5 ); | |
| 287 | PolynomialNearRing( 8/5 ) | |
| 288 | gap> L := LocalInterpolationNearRing ( P, 2 ); | |
| 289 | LocalInterpolationNearRing( PolynomialNearRing( 8/5 ), 2 ) | |
| 290 | gap> Size ( L ) / Size ( P ); | |
| 291 | 16 | |
| 292 | </pre> | |
| 293 | <p> | |
| 294 | <p> | |
| 295 | <h2><a name="SECT003">5.3 The group a transformation nearring acts on</a></h2> | |
| 296 | <p><p> | |
| 297 | <a name = "SSEC003.1"></a> | |
| 298 | <li><code>Gamma( </code><var>tfmnr</var><code> )</code> | |
| 299 | <p> | |
| 300 | The function <code>Gamma</code> returns the group on which the mappings of the | |
| 301 | nearring <var>tfmnr</var> act. | |
| 302 | <p> | |
| 303 | <pre> | |
| 304 | gap> Gamma ( PolynomialNearRing ( CyclicGroup ( 25 ) ) ); | |
| 305 | <pc group of size 25 with 2 generators> | |
| 306 | gap> IsCyclic (last); | |
| 307 | true | |
| 308 | </pre> | |
| 309 | <p> | |
| 310 | <p> | |
| 311 | <h2><a name="SECT004">5.4 Transformation nearrings and other nearrings</a></h2> | |
| 312 | <p><p> | |
| 313 | <a name = "SSEC004.1"></a> | |
| 314 | <li><code>AsTransformationNearRing( </code><var>nr</var><code> )</code> | |
| 315 | <p> | |
| 316 | Provided that <var>nr</var> is not already a transformation nearring, | |
| 317 | <code>AsTransformationNearRing</code> returns a transformation nearring that is isomorphic | |
| 318 | to the nearring <var>nr</var>. | |
| 319 | <p> | |
| 320 | <pre> | |
| 321 | gap> L := LibraryNearRing (GTW8_3, 12); | |
| 322 | LibraryNearRing(8/3, 12) | |
| 323 | gap> Lt := AsTransformationNearRing ( L ); | |
| 324 | < transformation nearring with 3 generators > | |
| 325 | gap> Gamma ( Lt ); | |
| 326 | 8/3 x C_2 | |
| 327 | </pre> | |
| 328 | <p> | |
| 329 | <a name = "SSEC004.2"></a> | |
| 330 | <li><code>AsExplicitMultiplicationNearRing( </code><var>nr</var><code> )</code> | |
| 331 | <p> | |
| 332 | Provided that <var>nr</var> is not already an explicit multiplication nearring | |
| 333 | (i. e. a transformation nearring), <code>AsExplicitMultiplicationNearRing</code> returns | |
| 334 | an explicit multiplication nearring that is isomorphic to the nearring <var>nr</var>. | |
| 335 | <p> | |
| 336 | <pre> | |
| 337 | gap> P := PolynomialNearRing ( GTW4_2 ); | |
| 338 | PolynomialNearRing( 4/2 ) | |
| 339 | gap> n := AsExplicitMultiplicationNearRing ( P ); | |
| 340 | ExplicitMultiplicationNearRing ( Group( | |
| 341 | [ ( 1, 2)( 5, 6)( 9,10)(13,14), ( 3, 4)( 7, 8)(11,12)(15,16), | |
| 342 | ( 7, 8)( 9,10)(13,14)(15,16) ]) , multiplication ) | |
| 343 | </pre> | |
| 344 | <p> | |
| 345 | <p> | |
| 346 | <h2><a name="SECT005">5.5 Noetherian quotients for transformation nearrings</a></h2> | |
| 347 | <p><p> | |
| 348 | <a name = "SSEC005.1"></a> | |
| 349 | <li><code>NoetherianQuotient( </code><var>tfmnr</var><code>, </code><var>target</var><code>, </code><var>source</var><code> )</code> | |
| 350 | <p> | |
| 351 | <code>NoetherianQuotient</code> returns the set of all mappings <i>t</i> in <var>tfmnr</var> | |
| 352 | with <i>t</i>(<tt>source</tt>) <font face="symbol">Í</font> <tt>target</tt>. | |
| 353 | <p> | |
| 354 | <pre> | |
| 355 | gap> G := SymmetricGroup ( 4 ); | |
| 356 | Sym( [ 1 .. 4 ] ) | |
| 357 | gap> V := First ( NormalSubgroups ( G ), x -> Size ( x ) = 4 ); | |
| 358 | Group([ (1,4)(2,3), (1,3)(2,4) ]) | |
| 359 | gap> P := InnerAutomorphismNearRing ( G ); | |
| 360 | InnerAutomorphismNearRing( Sym( [ 1 .. 4 ] ) ) | |
| 361 | gap> N := NoetherianQuotient ( P, V, G ); | |
| 362 | NoetherianQuotient( Group([ (1,4)(2,3), (1,3)(2,4) ]) ,Sym( | |
| 363 | [ 1 .. 4 ] ) ) | |
| 364 | gap> Size ( P ) / Size ( N ); | |
| 365 | 54 | |
| 366 | </pre> | |
| 367 | <p> | |
| 368 | <a name = "SSEC005.2"></a> | |
| 369 | <li><code>CongruenceNoetherianQuotient( </code><var>P</var><code>, </code><var>A</var><code>, </code><var>B</var><code>, </code><var>C</var><code> )</code> | |
| 370 | <p> | |
| 371 | <code>CongruenceNoetherianQuotient</code> returns the ideal of all those mappings in <var>P</var> that | |
| 372 | map every element of the group Gamma(P) into <var>C</var>, and maps two elements that | |
| 373 | are congruent modulo <var>B</var> into elements that are congruent modulo <var>A</var>. | |
| 374 | Input conditions: (1) <var>P</var> is the nearring of polynomial functions on a group G, | |
| 375 | (2) <var>A</var> is a normal subgroup of G, | |
| 376 | (3) <var>B</var> is a normal subgroup of G, | |
| 377 | (4) <var>C</var> is a normal subgroup of G, | |
| 378 | (5) [C,B] is less or equal to A. | |
| 379 | <pre> | |
| 380 | gap> G := GTW8_4; | |
| 381 | 8/4 | |
| 382 | gap> P := PolynomialNearRing (G); | |
| 383 | PolynomialNearRing( 8/4 ) | |
| 384 | gap> A := TrivialSubgroup (G); | |
| 385 | Group(()) | |
| 386 | gap> B := DerivedSubgroup (G); | |
| 387 | Group([ (1,3)(2,4) ]) | |
| 388 | gap> C := G; | |
| 389 | 8/4 | |
| 390 | gap> I := CongruenceNoetherianQuotient (P, A, B, C); | |
| 391 | < nearring ideal > | |
| 392 | gap> Size (P/I); | |
| 393 | 2 | |
| 394 | </pre> | |
| 395 | <p> | |
| 396 | <a name = "SSEC005.3"></a> | |
| 397 | <li><code>CongruenceNoetherianQuotientForInnerAutomorphismNearRings (</code><var>I</var><code>, </code><var>A</var><code>, </code><var>B</var><code>, </code><var>C</var><code> )</code> | |
| 398 | <p> | |
| 399 | <code>CongruenceNoetherianQuotientForInnerAutomorphismNearRings</code> returns the ideal of all those mappings in <var>I</var> that | |
| 400 | map every element of the group Gamma(I) into <var>C</var>, and maps two elements that | |
| 401 | are congruent modulo <var>B</var> into elements that are congruent modulo <var>A</var>. | |
| 402 | Input conditions: (1) <var>P</var> is the nearring of polynomial functions on a group G, | |
| 403 | (2) <var>A</var> is a normal subgroup of G, | |
| 404 | (3) <var>B</var> is a normal subgroup of G, | |
| 405 | (4) <var>C</var> is a normal subgroup of G, | |
| 406 | (5) [C,B] is less or equal to A. | |
| 407 | <pre> | |
| 408 | gap> G := GTW8_4; | |
| 409 | 8/4 | |
| 410 | gap> I := InnerAutomorphismNearRing (G); | |
| 411 | InnerAutomorphismNearRing( 8/4 ) | |
| 412 | gap> A := TrivialSubgroup (G); | |
| 413 | Group(()) | |
| 414 | gap> B := DerivedSubgroup (G); | |
| 415 | Group([ (1,3)(2,4) ]) | |
| 416 | gap> C := G; | |
| 417 | 8/4 | |
| 418 | gap> j := CongruenceNoetherianQuotientForInnerAutomorphismNearRings (I,A,B,C); | |
| 419 | < nearring ideal > | |
| 420 | gap> Size (I/j); | |
| 421 | 2 | |
| 422 | </pre> | |
| 423 | <p> | |
| 424 | <p> | |
| 425 | <h2><a name="SECT006">5.6 Zerosymmetric mappings</a></h2> | |
| 426 | <p><p> | |
| 427 | <a name = "SSEC006.1"></a> | |
| 428 | <li><code>ZeroSymmetricPart( </code><var>tfmnr</var><code> )</code> | |
| 429 | <p> | |
| 430 | <code>ZeroSymmetricPart</code> returns the nearring of all mappings <i>t</i> in | |
| 431 | <var>tfmnr</var> with <i>t</i>(0) = 0. | |
| 432 | <p> | |
| 433 | <pre> | |
| 434 | gap> g := GTW8_4; | |
| 435 | 8/4 | |
| 436 | gap> P := PolynomialNearRing ( g ); | |
| 437 | PolynomialNearRing( 8/4 ) | |
| 438 | gap> Zp := ZeroSymmetricPart ( P ); | |
| 439 | < transformation nearring with 4 generators > | |
| 440 | gap> InnerAutomorphismNearRing ( g ) = Zp; | |
| 441 | true | |
| 442 | </pre> | |
| 443 | <p> | |
| 444 | <p> | |
| 445 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP004.htm">Previous</a>] [<a href ="CHAP006.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 446 | <P> | |
| 447 | <address>SONATA manual<br>October 2018 | |
| 448 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 6 Nearring ideals</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP005.htm">Previous</a>] [<a href ="CHAP007.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>6 Nearring ideals</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP006.htm#SECT001">Construction of nearring ideals</a> | |
| 8 | <li> <A HREF="CHAP006.htm#SECT002">Testing for ideal properties</a> | |
| 9 | <li> <A HREF="CHAP006.htm#SECT003">Special ideal properties</a> | |
| 10 | <li> <A HREF="CHAP006.htm#SECT004">Generators of nearring ideals</a> | |
| 11 | <li> <A HREF="CHAP006.htm#SECT005">Near-ring ideal elements</a> | |
| 12 | <li> <A HREF="CHAP006.htm#SECT006">Random ideal elements</a> | |
| 13 | <li> <A HREF="CHAP006.htm#SECT007">Membership of an ideal</a> | |
| 14 | <li> <A HREF="CHAP006.htm#SECT008">Size of ideals</a> | |
| 15 | <li> <A HREF="CHAP006.htm#SECT009">Group reducts of ideals</a> | |
| 16 | <li> <A HREF="CHAP006.htm#SECT010">Comparision of ideals</a> | |
| 17 | <li> <A HREF="CHAP006.htm#SECT011">Operations with ideals</a> | |
| 18 | <li> <A HREF="CHAP006.htm#SECT012">Commutators</a> | |
| 19 | <li> <A HREF="CHAP006.htm#SECT013">Simple nearrings</a> | |
| 20 | <li> <A HREF="CHAP006.htm#SECT014">Factor nearrings</a> | |
| 21 | </ol><p> | |
| 22 | <p> | |
| 23 | For an introduction to nearring ideals we suggest <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>], | |
| 24 | <a href="biblio.htm#meldrum85:NATLWG"><[>meldrum85:NATLWG</cite></a>], and <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>]. | |
| 25 | <p> | |
| 26 | Ideals of nearrings can either be left, right or twosided ideals. However, | |
| 27 | all of them are called ideals. Mathematicians tend to use the expression | |
| 28 | ideal also for subgroups of the group reduct of the nearring. <font face="Gill Sans,Helvetica,Arial">GAP</font> does | |
| 29 | not allow that. | |
| 30 | <p> | |
| 31 | Left, right or twosided ideals in <font face="Gill Sans,Helvetica,Arial">GAP</font> form their own category <code>IsNRI</code>. | |
| 32 | Whenever a left, right or twosided ideal is constructed it lies in this | |
| 33 | category. The objects in this category are what <font face="Gill Sans,Helvetica,Arial">GAP</font> considers as ideals. | |
| 34 | We will refer to them as <code>NRI</code>s. | |
| 35 | <p> | |
| 36 | All the functions in this chapter can be applied to all types of nearrings. | |
| 37 | <p> | |
| 38 | The functions described in this chapter can be found in the source files | |
| 39 | <code>nrid.g?</code>, <code>idlatt.g?</code> and <code>nrconstr.g?</code>. | |
| 40 | <p> | |
| 41 | <p> | |
| 42 | <h2><a name="SECT001">6.1 Construction of nearring ideals</a></h2> | |
| 43 | <p><p> | |
| 44 | There are several ways to construct ideals in nearrings. | |
| 45 | <code>NearRingLeftIdealByGenerators</code>, <code>NearRingRightIdealByGenerators</code> and | |
| 46 | <code>NearRingIdealByGenerators</code> can be used to construct (left / right) | |
| 47 | ideals generated by a subset of the nearring. | |
| 48 | <code>NearRingLeftIdealBySubgroupNC</code>, <code>NearRingRightIdealBySubgroupNC</code> and | |
| 49 | <code>NearRingIdealBySubgroupNC</code> construct (left / right) ideals from a subgroup | |
| 50 | of the group reduct of the nearring which is an ideal. Finally | |
| 51 | <code>NearRingLeftIdeals</code>, <code>NearRingRightIdeals</code> and <code>NearRingIdeals</code> | |
| 52 | compute lists of all (left / right) ideals of a nearring. | |
| 53 | <p> | |
| 54 | <a name = "SSEC001.1"></a> | |
| 55 | <li><code>NearRingIdealByGenerators( </code><var>nr</var><code>, </code><var>gens</var><code> )</code> | |
| 56 | <p> | |
| 57 | The function <code>NearRingIdealByGenerators</code> takes as arguments a nearring <var>nr</var> | |
| 58 | and a list <var>gens</var> of arbitrarily many elements of <var>nr</var>. It returns the | |
| 59 | smallest ideal of <var>nr</var> containing all elements of <var>gens</var>. | |
| 60 | <p> | |
| 61 | <a name = "SSEC001.2"></a> | |
| 62 | <li><code>NearRingLeftIdealByGenerators( </code><var>nr</var><code>, </code><var>gens</var><code> )</code> | |
| 63 | <p> | |
| 64 | The function <code>NearRingLeftIdealByGenerators</code> takes as arguments a nearring <var>nr</var> | |
| 65 | and a list <var>gens</var> of arbitrarily many elements of <var>nr</var>. It returns the | |
| 66 | smallest left ideal of <var>nr</var> containing all elements of <var>gens</var>. | |
| 67 | <p> | |
| 68 | <a name = "SSEC001.3"></a> | |
| 69 | <li><code>NearRingRightIdealByGenerators( </code><var>nr</var><code>, </code><var>gens</var><code> )</code> | |
| 70 | <p> | |
| 71 | The function <code>NearRingRightIdealByGenerators</code> takes as arguments a nearring | |
| 72 | <var>nr</var> and a list <var>gens</var> of arbitrarily many elements of <var>nr</var>. It returns the | |
| 73 | smallest right ideal of <var>nr</var> containing all elements of <var>gens</var>. | |
| 74 | <p> | |
| 75 | <pre> | |
| 76 | gap> n := LibraryNearRing( GTW8_4, 12 ); | |
| 77 | LibraryNearRing(8/4, 12) | |
| 78 | gap> e := AsNearRingElement( n, (1,3)(2,4) ); | |
| 79 | ((1,3)(2,4)) | |
| 80 | gap> r := NearRingRightIdealByGenerators( n, [e] ); | |
| 81 | < nearring right ideal > | |
| 82 | gap> l := NearRingLeftIdealByGenerators( n, [e] ); | |
| 83 | < nearring left ideal > | |
| 84 | gap> i := NearRingIdealByGenerators( n, [e] ); | |
| 85 | < nearring ideal > | |
| 86 | gap> r = i; | |
| 87 | true | |
| 88 | gap> l = i; | |
| 89 | false | |
| 90 | gap> l = r; | |
| 91 | false | |
| 92 | </pre> | |
| 93 | <p> | |
| 94 | <a name = "SSEC001.4"></a> | |
| 95 | <li><code>NearRingIdealBySubgroupNC( </code><var>nr</var><code>, </code><var>S</var><code> )</code> | |
| 96 | <p> | |
| 97 | From a nearring <var>nr</var> and a subgroup <var>S</var> of the group reduct of <var>nr</var>, | |
| 98 | <code>NearRingIdealBySubgroupNC</code> constructs a (<font face="Gill Sans,Helvetica,Arial">GAP</font>--) ideal of <var>nr</var>. It is | |
| 99 | assumed (and hence not checked) that <var>S</var> is an ideal of <var>nr</var>. See Section | |
| 100 | <a href="CHAP006.htm#SSEC002.5">IsSubgroupNearRingLeftIdeal</a> for information how to check this. | |
| 101 | <p> | |
| 102 | <a name = "SSEC001.5"></a> | |
| 103 | <li><code>NearRingLeftIdealBySubgroupNC( </code><var>nr</var><code>, </code><var>S</var><code> )</code> | |
| 104 | <p> | |
| 105 | From a nearring <var>nr</var> and a subgroup <var>S</var> of the group reduct of <var>nr</var>, | |
| 106 | <code>NearRingLeftIdealBySubgroupNC</code> constructs a (<font face="Gill Sans,Helvetica,Arial">GAP</font>--) left ideal of <var>nr</var>. It | |
| 107 | is assumed (and hence not checked) that <var>S</var> is a left ideal of <var>nr</var>. See | |
| 108 | Section <a href="CHAP006.htm#SSEC002.5">IsSubgroupNearRingLeftIdeal</a> for information how to check this. | |
| 109 | <p> | |
| 110 | <a name = "SSEC001.6"></a> | |
| 111 | <li><code>NearRingRightIdealBySubgroupNC( </code><var>nr</var><code>, </code><var>S</var><code> )</code> | |
| 112 | <p> | |
| 113 | From a nearring <var>nr</var> and a subgroup <var>S</var> of the group reduct of <var>nr</var>, | |
| 114 | <code>NearRingRightIdealBySubgroupNC</code> constructs a (<font face="Gill Sans,Helvetica,Arial">GAP</font>--) right ideal of <var>nr</var>. | |
| 115 | It is assumed (and hence not checked) that <var>S</var> is a right ideal of <var>nr</var>. | |
| 116 | See Section <a href="CHAP006.htm#SSEC002.6">IsSubgroupNearRingRightIdeal</a> for information how to check this. | |
| 117 | <p> | |
| 118 | <pre> | |
| 119 | gap> a := GroupReduct( n ); | |
| 120 | 8/4 | |
| 121 | gap> nsgps := NormalSubgroups( a ); | |
| 122 | [ Group(()), Group([ (1,3)(2,4) ]), | |
| 123 | Group([ (1,3)(2,4), (1,2)(3,4) ]), Group([ (1,3)(2,4), (2,4) ]), | |
| 124 | Group([ (1,2,3,4), (1,3)(2,4) ]), 8/4 ] | |
| 125 | gap> l := Filtered( nsgps, | |
| 126 | > s -> IsSubgroupNearRingRightIdeal( n, s ) ); | |
| 127 | [ Group(()), Group([ (1,3)(2,4), (2,4) ]), 8/4 ] | |
| 128 | gap> l := List( l, | |
| 129 | > s -> NearRingRightIdealBySubgroupNC( n, s ) ); | |
| 130 | [ < nearring right ideal >, < nearring right ideal >, | |
| 131 | < nearring right ideal > ] | |
| 132 | </pre> | |
| 133 | <p> | |
| 134 | <a name = "SSEC001.7"></a> | |
| 135 | <li><code>NearRingIdeals( </code><var>nr</var><code> )</code> | |
| 136 | <p> | |
| 137 | <code>NearRingIdeals</code> computes all ideals of the nearring <var>nr</var>. The return value | |
| 138 | is a list of ideals of <var>nr</var> | |
| 139 | <p> | |
| 140 | For one-sided ideals the functions | |
| 141 | <p> | |
| 142 | <a name = "SSEC001.8"></a> | |
| 143 | <li><code>NearRingLeftIdeals( </code><var>nr</var><code> )</code> | |
| 144 | <p> | |
| 145 | and | |
| 146 | <p> | |
| 147 | <a name = "SSEC001.9"></a> | |
| 148 | <li><code>NearRingRightIdeals( </code><var>nr</var><code> )</code> | |
| 149 | <p> | |
| 150 | can be used. | |
| 151 | <p> | |
| 152 | <pre> | |
| 153 | gap> NearRingIdeals( n ); | |
| 154 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] | |
| 155 | gap> NearRingRightIdeals( n ); | |
| 156 | [ < nearring right ideal >, < nearring right ideal >, | |
| 157 | < nearring right ideal > ] | |
| 158 | gap> NearRingLeftIdeals( n ); | |
| 159 | [ < nearring left ideal >, < nearring left ideal >, < nearring left ideal >, | |
| 160 | < nearring left ideal > ] | |
| 161 | </pre> | |
| 162 | <p> | |
| 163 | <p> | |
| 164 | <h2><a name="SECT002">6.2 Testing for ideal properties</a></h2> | |
| 165 | <p><p> | |
| 166 | <a name = "SSEC002.1"></a> | |
| 167 | <li><code>IsNRI( </code><var>obj</var><code> )</code> | |
| 168 | <p> | |
| 169 | <code>IsNRI</code> returns <code>true</code> if the object <var>obj</var> is a left ideal, a right ideal or | |
| 170 | an ideal of a nearring. (Such an object may be considered as a (one or | |
| 171 | twosided) <font face="Gill Sans,Helvetica,Arial">GAP</font> -- nearring ideal.) | |
| 172 | <p> | |
| 173 | <a name = "SSEC002.2"></a> | |
| 174 | <li><code>IsNearRingLeftIdeal( </code><var>I</var><code> )</code> | |
| 175 | <p> | |
| 176 | The function <code>IsNearRingLeftIdeal</code> can be applied to any <code>NRI</code>. | |
| 177 | It returns <code>true</code> if <var>I</var> is a left ideal in its parent nearring. | |
| 178 | <p> | |
| 179 | <a name = "SSEC002.3"></a> | |
| 180 | <li><code>IsNearRingRightIdeal( </code><var>I</var><code> )</code> | |
| 181 | <p> | |
| 182 | The function <code>IsNearRingRightIdeal</code> can be applied to any <code>NRI</code>. | |
| 183 | It returns <code>true</code> if <var>I</var> is a right ideal in its parent nearring. | |
| 184 | <p> | |
| 185 | <a name = "SSEC002.4"></a> | |
| 186 | <li><code>IsNearRingIdeal( </code><var>I</var><code> )</code> | |
| 187 | <p> | |
| 188 | The function <code>IsNearRingIdeal</code> can be applied to any <code>NRI</code>. | |
| 189 | It returns <code>true</code> if <var>I</var> is an ideal in its parent nearring. | |
| 190 | <p> | |
| 191 | <pre> | |
| 192 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 193 | LibraryNearRing(6/2, 39) | |
| 194 | gap> e := Enumerator(n)[3]; | |
| 195 | ((1,3,2)) | |
| 196 | gap> l := NearRingLeftIdealByGenerators( n, [e] ); | |
| 197 | < nearring left ideal > | |
| 198 | gap> IsNRI( l ); | |
| 199 | true | |
| 200 | gap> IsNearRingLeftIdeal( l ); | |
| 201 | true | |
| 202 | gap> IsNearRingRightIdeal( l ); | |
| 203 | true | |
| 204 | gap> l; | |
| 205 | < nearring ideal > | |
| 206 | </pre> | |
| 207 | <p> | |
| 208 | <a name = "SSEC002.5"></a> | |
| 209 | <li><code>IsSubgroupNearRingLeftIdeal( </code><var>nr</var><code>, </code><var>S</var><code> )</code> | |
| 210 | <p> | |
| 211 | Let (<i>N</i>,+,·) be a nearring. A subgroup <i>S</i> of the group (<i>N</i>,+) is a | |
| 212 | <strong>left ideal</strong> of <i>N</i> if for all <i>a</i>, <i>b</i> in <i>N</i> and <i>s</i> in <i>S</i>:\ | |
| 213 | <i>a</i>·(<i>b</i>+<i>s</i>)<font face="symbol">-</font><i>a</i>·<i>b</i> in <i>S</i>. | |
| 214 | <code>IsSubgroupNearRingLeftIdeal</code> takes as arguments a nearring <var>nr</var> and a subgroup | |
| 215 | <var>S</var> of the group reduct of <var>nr</var> and returns <code>true</code> if <var>S</var> is a nearring | |
| 216 | ideal of <var>nr</var> and <code>false</code> otherwise. | |
| 217 | <p> | |
| 218 | <strong>Note</strong>, that if <code>IsSubgroupNearRingLeftIdeal</code> returns <code>true</code> this means that | |
| 219 | <var>S</var> is a left ideal only in the mathematical sense, not in <font face="Gill Sans,Helvetica,Arial">GAP</font>--sense (it is | |
| 220 | a group, not a left ideal). You can use <code>NearRingLeftIdealBySubgroupNC</code> (see | |
| 221 | Section <a href="CHAP006.htm#SSEC001.5">NearRingLeftIdealBySubgroupNC</a>) to construct the corresponding left | |
| 222 | ideal. | |
| 223 | <p> | |
| 224 | <a name = "SSEC002.6"></a> | |
| 225 | <li><code>IsSubgroupNearRingRightIdeal( </code><var>nr</var><code>, </code><var>S</var><code> )</code> | |
| 226 | <p> | |
| 227 | Let (<i>N</i>,+,·) be a nearring. A subgroup <i>S</i> of the group (<i>N</i>,+) is a | |
| 228 | <strong>right ideal</strong> of <i>N</i> if <i>S</i>·<i>N</i> <font face="symbol">Í</font> <i>S</i>. | |
| 229 | <code>IsSubgroupNearRingRightIdeal</code> takes as arguments a nearring <var>nr</var> and a | |
| 230 | subgroup <var>S</var> of the group reduct of <var>nr</var> and returns <code>true</code> if <var>S</var> is a | |
| 231 | right ideal of <var>nr</var> and <code>false</code> otherwise. | |
| 232 | <p> | |
| 233 | <strong>Note</strong>, that if <code>IsSubgroupNearRingRightIdeal</code> returns <code>true</code> this means that | |
| 234 | <var>S</var> is a right ideal only in the mathematical sense, not in <font face="Gill Sans,Helvetica,Arial">GAP</font>--sense (it | |
| 235 | is a group, not a right ideal). You can use | |
| 236 | <code>NearRingRightIdealBySubgroupNC</code> (see Section | |
| 237 | <a href="CHAP006.htm#SSEC001.6">NearRingRightIdealBySubgroupNC</a>) to construct the corresponding right ideal. | |
| 238 | <p> | |
| 239 | <pre> | |
| 240 | gap> n := LibraryNearRing( GTW6_2, 39 ); | |
| 241 | LibraryNearRing(6/2, 39) | |
| 242 | gap> s := Subgroups( GroupReduct( n ) ); | |
| 243 | [ Group(()), Group([ (2,3) ]), Group([ (1,3) ]), Group([ (1,2) ]), | |
| 244 | Group([ (1,3,2) ]), Group([ (1,2,3), (1,2) ]) ] | |
| 245 | gap> List( s, sg -> IsSubgroupNearRingLeftIdeal( n, sg ) ); | |
| 246 | [ true, false, false, false, true, true ] | |
| 247 | gap> List( s, sg -> IsSubgroupNearRingRightIdeal( n, sg ) ); | |
| 248 | [ true, false, false, false, true, true ] | |
| 249 | </pre> | |
| 250 | <p> | |
| 251 | <p> | |
| 252 | <h2><a name="SECT003">6.3 Special ideal properties</a></h2> | |
| 253 | <p><p> | |
| 254 | <a name = "SSEC003.1"></a> | |
| 255 | <li><code>IsPrimeNearRingIdeal( </code><var>I</var><code> )</code> | |
| 256 | <p> | |
| 257 | An ideal <i>I</i> of a nearring <i>N</i> is <strong>prime</strong> if for any two ideals <i>J</i> and <i>K</i> | |
| 258 | of <i>N</i> whenever <i>J</i>·<i>K</i> is contained in <i>I</i> then at least one of them is | |
| 259 | contained in <i>I</i>. | |
| 260 | <code>IsPrimeNearRingIdeal</code> returns <code>true</code> if <var>I</var> is a prime ideal in its parent | |
| 261 | nearring and <code>false</code> otherwise. | |
| 262 | <p> | |
| 263 | <pre> | |
| 264 | gap> n := LibraryNearRingWithOne( GTW27_2, 5 ); | |
| 265 | LibraryNearRingWithOne(27/2, 5) | |
| 266 | gap> Filtered( NearRingIdeals( n ), IsPrimeNearRingIdeal ); | |
| 267 | [ < nearring ideal of size 9 >, < nearring ideal of size 27 > ] | |
| 268 | </pre> | |
| 269 | <p> | |
| 270 | <a name = "SSEC003.2"></a> | |
| 271 | <li><code>IsMaximalNearRingIdeal( </code><var>I</var><code> )</code> | |
| 272 | <p> | |
| 273 | A proper ideal <i>I</i> of a nearring <i>N</i> is <strong>maximal</strong> if there is no | |
| 274 | proper ideal containing <i>I</i> properly. | |
| 275 | <code>IsMaximalNearRingIdeal( </code><var>I</var><code> ) returns `true</code> if <var>I</var> is a | |
| 276 | maximal ideal in its parent nearring and <code>false</code> otherwise. | |
| 277 | <p> | |
| 278 | <pre> | |
| 279 | gap> n := LibraryNearRingWithOne( GTW27_2, 5 ); | |
| 280 | LibraryNearRingWithOne(27/2, 5) | |
| 281 | gap> Filtered( NearRingIdeals( n ), IsMaximalNearRingIdeal ); | |
| 282 | [ < nearring ideal of size 9 > ] | |
| 283 | </pre> | |
| 284 | <p> | |
| 285 | <p> | |
| 286 | <h2><a name="SECT004">6.4 Generators of nearring ideals</a></h2> | |
| 287 | <p><p> | |
| 288 | <a name = "SSEC004.1"></a> | |
| 289 | <li><code>GeneratorsOfNearRingIdeal( </code><var>I</var><code> )</code> | |
| 290 | <p> | |
| 291 | For an <code>NRI</code> <var>I</var> the function <code>GeneratorsOfNearRingIdeal</code> | |
| 292 | returns a set of elements of the parent nearring of <var>I</var> that generates <var>I</var> | |
| 293 | as an ideal. | |
| 294 | <p> | |
| 295 | <a name = "SSEC004.2"></a> | |
| 296 | <li><code>GeneratorsOfNearRingLeftIdeal( </code><var>I</var><code> )</code> | |
| 297 | <p> | |
| 298 | For an <code>NRI</code> <var>I</var> the function <code>GeneratorsOfNearRingLeftIdeal</code> | |
| 299 | returns a set of elements of the parent nearring of <var>I</var> that generates <var>I</var> | |
| 300 | as a left ideal. | |
| 301 | <p> | |
| 302 | <a name = "SSEC004.3"></a> | |
| 303 | <li><code>GeneratorsOfNearRingRightIdeal( </code><var>I</var><code> )</code> | |
| 304 | <p> | |
| 305 | For an <code>NRI</code> <var>I</var> the function <code>GeneratorsOfNearRingRightIdeal</code> | |
| 306 | returns a set of elements of the parent nearring of <var>I</var> that generates <var>I</var> | |
| 307 | as a right ideal. | |
| 308 | <p> | |
| 309 | <p> | |
| 310 | <h2><a name="SECT005">6.5 Near-ring ideal elements</a></h2> | |
| 311 | <p><p> | |
| 312 | <a name = "SSEC005.1"></a> | |
| 313 | <li><code>AsList( </code><var>I</var><code> )</code> | |
| 314 | <p> | |
| 315 | The function <code>AsList</code> computes the elements of the (left / right) ideal <var>I</var>. | |
| 316 | It returns the elements as a list. | |
| 317 | <p> | |
| 318 | <a name = "SSEC005.2"></a> | |
| 319 | <li><code>AsSortedList( </code><var>I</var><code> )</code> | |
| 320 | <p> | |
| 321 | does essentially the same, but returns a set of elements. | |
| 322 | <p> | |
| 323 | <a name = "SSEC005.3"></a> | |
| 324 | <li><code>Enumerator( </code><var>I</var><code> )</code> | |
| 325 | <p> | |
| 326 | does essentially the same as <code>AsList</code>, but returns an enumerator for the | |
| 327 | elements of <var>nr</var>. | |
| 328 | <p> | |
| 329 | <pre> | |
| 330 | gap> n := LibraryNearRing( GTW8_2, 2 ); | |
| 331 | LibraryNearRing(8/2, 2) | |
| 332 | gap> li := NearRingLeftIdeals( n ); | |
| 333 | [ < nearring left ideal >, < nearring left ideal >, | |
| 334 | < nearring left ideal >, < nearring left ideal >, | |
| 335 | < nearring left ideal >, < nearring left ideal > ] | |
| 336 | gap> l := li[3]; | |
| 337 | < nearring left ideal > | |
| 338 | gap> e := Enumerator( l );; | |
| 339 | gap> e[2]; | |
| 340 | ((1,2)(3,6,5,4)) | |
| 341 | gap> AsList( e ); AsList( l ); | |
| 342 | [ (()), ((1,2)(3,6,5,4)), ((3,5)(4,6)), ((1,2)(3,4,5,6)) ] | |
| 343 | [ (()), ((1,2)(3,6,5,4)), ((3,5)(4,6)), ((1,2)(3,4,5,6)) ] | |
| 344 | </pre> | |
| 345 | <p> | |
| 346 | <p> | |
| 347 | <h2><a name="SECT006">6.6 Random ideal elements</a></h2> | |
| 348 | <p><p> | |
| 349 | <a name = "SSEC006.1"></a> | |
| 350 | <li><code>Random( </code><var>I</var><code> )</code> | |
| 351 | <p> | |
| 352 | <code>Random</code> returns a random element of the (left / right) ideal <var>I</var>. | |
| 353 | <p> | |
| 354 | <pre> | |
| 355 | gap> Random( l ); | |
| 356 | ((3,5)(4,6)) | |
| 357 | </pre> | |
| 358 | <p> | |
| 359 | <p> | |
| 360 | <h2><a name="SECT007">6.7 Membership of an ideal</a></h2> | |
| 361 | <p><p> | |
| 362 | For a (left / right) ideal <var>I</var> of a nearring <i>N</i> and an element <var>n</var> of <i>N</i> | |
| 363 | <p> | |
| 364 | <a name = "SSEC007.1"></a> | |
| 365 | <li><code></code><var>n</var><code> in </code><var>I</var><code></code> | |
| 366 | <p> | |
| 367 | tests whether <var>n</var> is an element of <var>I</var>. | |
| 368 | <p> | |
| 369 | <pre> | |
| 370 | gap> Random( n ) in l; | |
| 371 | true | |
| 372 | gap> Random( n ) in l; | |
| 373 | false | |
| 374 | </pre> | |
| 375 | <p> | |
| 376 | <p> | |
| 377 | <h2><a name="SECT008">6.8 Size of ideals</a></h2> | |
| 378 | <p><p> | |
| 379 | <a name = "SSEC008.1"></a> | |
| 380 | <li><code>Size( </code><var>I</var><code> )</code> | |
| 381 | <p> | |
| 382 | <code>Size</code> returns the number of elements of the (left / right) ideal <var>I</var>. | |
| 383 | <p> | |
| 384 | <p> | |
| 385 | <h2><a name="SECT009">6.9 Group reducts of ideals</a></h2> | |
| 386 | <p><p> | |
| 387 | <a name = "SSEC009.1"></a> | |
| 388 | <li><code>GroupReduct( </code><var>I</var><code> )</code> | |
| 389 | <p> | |
| 390 | <code>GroupReduct</code> returns the group reduct of the (left / right) ideal <var>I</var>. | |
| 391 | <p> | |
| 392 | <p> | |
| 393 | <h2><a name="SECT010">6.10 Comparision of ideals</a></h2> | |
| 394 | <p><p> | |
| 395 | <a name = "SSEC010.1"></a> | |
| 396 | <li><code></code><var>I</var><code> = </code><var>J</var><code></code> | |
| 397 | <p> | |
| 398 | If <var>I</var> and <var>J</var> are (left / right) ideals of the same nearring and consist of | |
| 399 | the same elements, then <code>true</code> is returned. Otherwise the answer is <code>false</code>. | |
| 400 | <p> | |
| 401 | <p> | |
| 402 | <h2><a name="SECT011">6.11 Operations with ideals</a></h2> | |
| 403 | <p><p> | |
| 404 | The most important operations for nearring (left / right) ideals are <strong>meet</strong> | |
| 405 | and <strong>join</strong> in the lattice. <font face="Gill Sans,Helvetica,Arial">GAP</font> offers the functions <code>Intersection</code>, | |
| 406 | <code>ClosureNearRingLeftIdeal</code>, <code>ClosureNearRingRightIdeal</code> and | |
| 407 | <code>ClosureNearRingLeftIdeal</code> for this purpose. | |
| 408 | <p> | |
| 409 | <a name = "SSEC011.1"></a> | |
| 410 | <li><code>Intersection( </code><var>ideallist</var><code> )</code> | |
| 411 | <p> | |
| 412 | computes the intersection of the (left / right) ideals in the list <var>ideallist</var>. | |
| 413 | All of the (left / right) ideals in <var>ideallist</var> must be (left / right) ideals | |
| 414 | of the same nearring. | |
| 415 | <p> | |
| 416 | <a name = "SSEC011.2"></a> | |
| 417 | <li><code>Intersection( </code><var>I1</var><code>, ..., </code><var>In</var><code> )</code> | |
| 418 | <p> | |
| 419 | computes the intersection of the (left / right) ideals <var>I1</var>, ..., <var>In</var>. | |
| 420 | <p> | |
| 421 | In both cases the result is again a (left / right) ideal. | |
| 422 | <p> | |
| 423 | <a name = "SSEC011.3"></a> | |
| 424 | <li><code>ClosureNearRingLeftIdeal( </code><var>L1</var><code>, </code><var>L2</var><code> )</code> | |
| 425 | <p> | |
| 426 | The function <code>ClosureNearRingLeftIdeal</code> computes the left ideal <var>L1</var> + <var>L2</var> | |
| 427 | of the nearRing <i>N</i> if both <var>L1</var> and <var>L2</var> are (left) ideals of <i>N</i>. | |
| 428 | <p> | |
| 429 | <a name = "SSEC011.4"></a> | |
| 430 | <li><code>ClosureNearRingRightIdeal( </code><var>R1</var><code>, </code><var>R2</var><code> )</code> | |
| 431 | <p> | |
| 432 | The function <code>ClosureNearRingRightIdeal</code> computes the right ideal <var>L1</var> + <var>L2</var> | |
| 433 | of the nearring <i>N</i> if both <var>R1</var> and <var>R2</var> are (right) ideals of <i>N</i>. | |
| 434 | <p> | |
| 435 | <a name = "SSEC011.5"></a> | |
| 436 | <li><code>ClosureNearRingIdeal( </code><var>I1</var><code>, </code><var>I2</var><code> )</code> | |
| 437 | <p> | |
| 438 | The function <code>ClosureNearRingIdeal</code> computes the ideal <var>L1</var> + <var>L2</var> | |
| 439 | of the nearring <i>N</i> if both <var>I1</var> and <var>I2</var> are ideals of <i>N</i>. | |
| 440 | <p> | |
| 441 | <p> | |
| 442 | <h2><a name="SECT012">6.12 Commutators</a></h2> | |
| 443 | <p><p> | |
| 444 | <a name = "SSEC012.1"></a> | |
| 445 | <li><code>NearRingCommutator( </code><var>I</var><code>, </code><var>J</var><code> )</code> | |
| 446 | <p> | |
| 447 | The function <code>NearRingCommutator</code> returns the commutator of the two | |
| 448 | ideals <var>I</var> and <var>J</var> of a common nearring. | |
| 449 | <p> | |
| 450 | <pre> | |
| 451 | gap> l := LibraryNearRing( GTW6_2, 3 ); | |
| 452 | LibraryNearRing(6/2, 3) | |
| 453 | gap> i := NearRingIdeals( l ); | |
| 454 | [ < nearring ideal >, < nearring ideal > ] | |
| 455 | gap> List( i, Size ); | |
| 456 | [ 1, 6 ] | |
| 457 | gap> NearRingCommutator( i[2], i[2] ); | |
| 458 | < nearring ideal of size 6 > | |
| 459 | </pre> | |
| 460 | <p> | |
| 461 | The function <code>PrintNearRingCommutatorsTable</code> prints a complete overview | |
| 462 | over the action of the commutator operator on a group. | |
| 463 | <p> | |
| 464 | <pre> | |
| 465 | gap> l := LibraryNearRing( GTW8_4, 13 ); | |
| 466 | LibraryNearRing(8/4, 13) | |
| 467 | gap> NearRingIdeals( l ); | |
| 468 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] | |
| 469 | gap> PrintNearRingCommutatorsTable( l ); | |
| 470 | [ 1, 1, 1 ] | |
| 471 | [ 1, 1, 2 ] | |
| 472 | [ 1, 2, 2 ] | |
| 473 | </pre> | |
| 474 | <p> | |
| 475 | <p> | |
| 476 | <h2><a name="SECT013">6.13 Simple nearrings</a></h2> | |
| 477 | <p><p> | |
| 478 | <a name = "SSEC013.1"></a> | |
| 479 | <li><code>IsSimpleNearRing( </code><var>nr</var><code> )</code> | |
| 480 | <p> | |
| 481 | The function <code>IsSimpleNearRing</code> returns <code>true</code> if the nearring <var>nr</var> has | |
| 482 | no proper (two-sided) ideals. | |
| 483 | <p> | |
| 484 | <pre> | |
| 485 | gap> NumberLibraryNearRings( GTW4_2 ); | |
| 486 | 23 | |
| 487 | gap> Filtered( AllLibraryNearRings( GTW4_2 ), IsSimpleNearRing ); | |
| 488 | [ LibraryNearRing(4/2, 3), LibraryNearRing(4/2, 16), | |
| 489 | LibraryNearRing(4/2, 17) ] | |
| 490 | </pre> | |
| 491 | <p> | |
| 492 | <p> | |
| 493 | <h2><a name="SECT014">6.14 Factor nearrings</a></h2> | |
| 494 | <p><p> | |
| 495 | <a name = "SSEC014.1"></a> | |
| 496 | <li><code>FactorNearRing( </code><var>nr</var><code>, </code><var>I</var><code> )</code> | |
| 497 | <p> | |
| 498 | For a nearring <var>nr</var> and an ideal <var>I</var> of the nearring <var>nr</var> the function | |
| 499 | <code>FactorNearRing</code> returns the factor nearring of <var>nr</var> modulo the ideal <var>I</var>. | |
| 500 | Alternatively, | |
| 501 | <p> | |
| 502 | <a name = "SSEC014.2"></a> | |
| 503 | <li><code></code><var>nr</var><code> / </code><var>I</var><code></code> | |
| 504 | <p> | |
| 505 | can be used and has the same effect. | |
| 506 | <p> | |
| 507 | The result is always an <code>ExplicitMultiplicationNearRing</code>, so all functions | |
| 508 | for such nearrings can be applied to the factor nearring. | |
| 509 | <p> | |
| 510 | <pre> | |
| 511 | gap> n := LibraryNearRing( GTW8_2, 2 ); | |
| 512 | LibraryNearRing(8/2, 2) | |
| 513 | gap> e := AsNearRingElement( n, (1,2) ); | |
| 514 | ((1,2)) | |
| 515 | gap> e in n; | |
| 516 | true | |
| 517 | gap> i := NearRingRightIdealByGenerators( n, [e] ); | |
| 518 | < nearring right ideal > | |
| 519 | gap> Size(i); | |
| 520 | 4 | |
| 521 | gap> IsNearRingLeftIdeal( i ); | |
| 522 | true | |
| 523 | gap> i; | |
| 524 | < nearring ideal of size 4 > | |
| 525 | gap> f := n/i; | |
| 526 | FactorNearRing( LibraryNearRing(8/2, 2), < nearring ideal of size 4 > ) | |
| 527 | gap> IdLibraryNearRing(f); | |
| 528 | [ 2/1, 1 ] | |
| 529 | </pre> | |
| 530 | <p> | |
| 531 | <p> | |
| 532 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP005.htm">Previous</a>] [<a href ="CHAP007.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 533 | <P> | |
| 534 | <address>SONATA manual<br>October 2018 | |
| 535 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 7 Graphic ideal lattices (X-GAP only)</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP006.htm">Previous</a>] [<a href ="CHAP008.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>7 Graphic ideal lattices (X-GAP only)</h1><p> | |
| 4 | <p> | |
| 5 | If you run SONATA under XGAP it is possible to study ideal lattices of | |
| 6 | nearrings graphically. | |
| 7 | <p> | |
| 8 | <a name = ""></a> | |
| 9 | <li><code>GraphicIdealLattice( </code><var>nr</var><code>, </code><var>string</var><code> )</code> | |
| 10 | <p> | |
| 11 | The function <code>GraphicIdealLattice</code> computes one- and two-sided | |
| 12 | nearring ideals and uses XGAP's graphic capabilities to draw the ideal | |
| 13 | lattice of the nearring <var>nr</var>. The string <var>string</var> determines, which | |
| 14 | ideals are shown: | |
| 15 | <p> | |
| 16 | If <var>string</var> contains the letter <code>l</code>, left ideals are shown, if | |
| 17 | <var>string</var> contains the letter <code>r</code>, right ideals are shown, and if | |
| 18 | <var>string</var> contains the letter <code>i</code>, two-sided ideals are shown. Any | |
| 19 | combination of these letters is possible. | |
| 20 | <p> | |
| 21 | Right ideals of the nearring are represented by squares, left ideals | |
| 22 | by diamonds and two-sided ideals by circles. It is possible, that | |
| 23 | two-sided ideals are shown as right or left ideals, if the two-sided | |
| 24 | ideal property has not yet been tested. | |
| 25 | <p> | |
| 26 | Left clicking on an ideal allows one to select the ideal and determine | |
| 27 | more information about the ideal. Choosing <code>Ideal type</code> from the | |
| 28 | <code>Ideals</code>-menu determines, whether the selected ideal is two-sided (in | |
| 29 | which case its shape changes to a circle immediately). On a right | |
| 30 | click on an ideal a window opens showing more information about the | |
| 31 | ideal, such as its size and the isomorphism class of the factor | |
| 32 | nearring by the ideal (if it is two-sided). The information is | |
| 33 | computed and displayed as soon as you click on the corresponding entry | |
| 34 | in the window. Finally clicking on <code>Export ideal to GAP</code> makes the | |
| 35 | ideal the last output of XGAP's main window, where you may then go on | |
| 36 | working with it. | |
| 37 | <p> | |
| 38 | It is also possible to select several ideals at the same time pressing | |
| 39 | the Ctrl-key while left clicking on the ideals. When several ideals | |
| 40 | are selected it is possible to compute their sums and intersection | |
| 41 | from the corresponding <code>Ideals</code>-menu entries. The result of the | |
| 42 | computation is then indicated by green color. | |
| 43 | <p> | |
| 44 | <p> | |
| 45 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP006.htm">Previous</a>] [<a href ="CHAP008.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 46 | <P> | |
| 47 | <address>SONATA manual<br>October 2018 | |
| 48 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 8 N-groups</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP007.htm">Previous</a>] [<a href ="CHAP009.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>8 N-groups</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP008.htm#SECT001">Construction of N-groups</a> | |
| 8 | <li> <A HREF="CHAP008.htm#SECT002">Operation tables of N-groups</a> | |
| 9 | <li> <A HREF="CHAP008.htm#SECT003">Functions for N-groups</a> | |
| 10 | <li> <A HREF="CHAP008.htm#SECT004">N-subgroups</a> | |
| 11 | <li> <A HREF="CHAP008.htm#SECT005">N0-subgroups</a> | |
| 12 | <li> <A HREF="CHAP008.htm#SECT006">Ideals of N-groups</a> | |
| 13 | <li> <A HREF="CHAP008.htm#SECT007">Special properties of N-groups</a> | |
| 14 | <li> <A HREF="CHAP008.htm#SECT008">Noetherian quotients</a> | |
| 15 | <li> <A HREF="CHAP008.htm#SECT009">Nearring radicals</a> | |
| 16 | </ol><p> | |
| 17 | <p> | |
| 18 | In SONATA every N-group is a group, the only difference is, that there | |
| 19 | is a nearring that acts on the group. And since in SONATA all | |
| 20 | nearrings are left distributive, they act on the elements of an | |
| 21 | N-group from the right. <strong>Note</strong>, that the elements of an N-group are | |
| 22 | added via <code>*</code>, not <code>+</code>. | |
| 23 | <p> | |
| 24 | The functions described in this section can be found in the source files | |
| 25 | <code>ngroups.g?</code>. | |
| 26 | <p> | |
| 27 | <p> | |
| 28 | <h2><a name="SECT001">8.1 Construction of N-groups</a></h2> | |
| 29 | <p><p> | |
| 30 | There is a natural way to construct an N-group. It is to take a group, | |
| 31 | a nearring and define an action of the nearring on the group. The | |
| 32 | function <code>NGroup</code> allows one to do this. The special case, where | |
| 33 | (the group reduct of) a nearring is viewed as an N-group over the | |
| 34 | nearring itself, can be constructed easily via | |
| 35 | <code>NGroupByNearRingMultiplication</code>. | |
| 36 | <p> | |
| 37 | <a name = "SSEC001.1"></a> | |
| 38 | <li><code>NGroup( </code><var>G</var><code>, </code><var>nr</var><code>, </code><var>action</var><code> )</code> | |
| 39 | <p> | |
| 40 | The function <code>NGroup</code> has three arguments. <var>G</var> must be a group, <var>nr</var> the | |
| 41 | nearring that acts on the group and <var>action</var> a binary operation from the | |
| 42 | direct product of <var>G</var> and <var>nr</var> into <var>G</var>. It returns the N-group. | |
| 43 | <p> | |
| 44 | <pre> | |
| 45 | gap> G := GTW4_2; | |
| 46 | 4/2 | |
| 47 | gap> n := MapNearRing( G ); | |
| 48 | TransformationNearRing(4/2) | |
| 49 | gap> action := function ( g, f ) | |
| 50 | > return Image( f, g ); | |
| 51 | > end; | |
| 52 | function ( g, f ) ... end | |
| 53 | gap> gamma := NGroup( G, n, action ); | |
| 54 | < N-group of TransformationNearRing(4/2) > | |
| 55 | gap> IsNGroup( gamma ); | |
| 56 | true | |
| 57 | gap> NearRingActingOnNGroup( gamma ); | |
| 58 | TransformationNearRing(4/2) | |
| 59 | gap> ActionOfNearRingOnNGroup( gamma ); | |
| 60 | function ( g, f ) ... end | |
| 61 | gap> Print( ActionOfNearRingOnNGroup( gamma ) ); | |
| 62 | function ( g, f ) | |
| 63 | return Image( f, g ); | |
| 64 | </pre> | |
| 65 | <p> | |
| 66 | <a name = "SSEC001.2"></a> | |
| 67 | <li><code>NGroupByNearRingMultiplication( </code><var>nr</var><code> )</code> | |
| 68 | <p> | |
| 69 | For every (left) nearring (<i>N</i>,+,·) the group (<i>N</i>,+) is an N-group | |
| 70 | over <i>N</i> with respect to nearring multiplication from the right as the | |
| 71 | action. The function <code>NGroupByNearRingMultiplication</code> returns this | |
| 72 | N-group of the nearring <var>nr</var>. | |
| 73 | <p> | |
| 74 | <pre> | |
| 75 | gap> n := LibraryNearRing( GTW8_2, 3 ); | |
| 76 | LibraryNearRing(8/2, 3) | |
| 77 | gap> NGroupByNearRingMultiplication( n ) = GTW8_2; | |
| 78 | true | |
| 79 | </pre> | |
| 80 | <p> | |
| 81 | <a name = "SSEC001.3"></a> | |
| 82 | <li><code>NGroupByApplication( </code><var>tfmnr</var><code> )</code> | |
| 83 | <p> | |
| 84 | For a nearring <i>T</i> of transformations on a group <i>G</i>, <i>G</i> is an | |
| 85 | N-group of <i>T</i> with the application of functions as the action. The | |
| 86 | function <code>NGroupByApplication</code> returns this <code>N-group</code> of the nearring | |
| 87 | <var>tfmnr</var>. | |
| 88 | <p> | |
| 89 | Another way to construct an N-Group is to take a nearring <i>N</i>, a right | |
| 90 | ideal <i>R</i> and let <i>N</i> act on the factor <i>N</i>/<i>R</i> in the canonical way. | |
| 91 | This is accomplished by | |
| 92 | <p> | |
| 93 | <a name = "SSEC001.4"></a> | |
| 94 | <li><code>NGroupByRightIdealFactor( </code><var>nr</var><code>, </code><var>R</var><code> )</code> | |
| 95 | <p> | |
| 96 | The function <code>NGroupByRightIdealFactor</code> has two arguments, a nearring | |
| 97 | <var>nr</var> and a right ideal <var>R</var>. It returns the N-group <var>nr</var>/<var>R</var>. | |
| 98 | <p> | |
| 99 | <pre> | |
| 100 | gap> N := LibraryNearRing( GTW4_2, 11 ); | |
| 101 | LibraryNearRing(4/2, 11) | |
| 102 | gap> R := NearRingRightIdeals( N )[ 3 ]; | |
| 103 | < nearring right ideal > | |
| 104 | gap> ng := NGroupByRightIdealFactor( N, R ); | |
| 105 | < N-group of LibraryNearRing(4/2, 11) > | |
| 106 | gap> PrintTable( ng ); | |
| 107 | Let: | |
| 108 | (0,0) := (()) | |
| 109 | (1,0) := ((3,4)) | |
| 110 | (0,1) := ((1,2)) | |
| 111 | (1,1) := ((1,2)(3,4)) | |
| 112 | -------------------------------------------------------------------- | |
| 113 | g0 := <identity> of ... | |
| 114 | g1 := f1 | |
| 115 | ||
| 116 | N = LibraryNearRing(4/2, 11) acts on | |
| 117 | G = Group( [ f1 ] ) | |
| 118 | from the right by the following action: | |
| 119 | ||
| 120 | | g0 g1 | |
| 121 | --------------- | |
| 122 | (0,0) | g0 g0 | |
| 123 | (1,0) | g0 g0 | |
| 124 | (0,1) | g0 g1 | |
| 125 | (1,1) | g0 g1 | |
| 126 | ||
| 127 | </pre> | |
| 128 | <p> | |
| 129 | <p> | |
| 130 | <h2><a name="SECT002">8.2 Operation tables of N-groups</a></h2> | |
| 131 | <p><p> | |
| 132 | <a name = "SSEC002.1"></a> | |
| 133 | <li><code>PrintTable( </code><var>G</var><code> )</code> | |
| 134 | <p> | |
| 135 | The function <code>PrintTable</code> prints out the operation table of the | |
| 136 | action of a nearring on its N-group <var>G</var> | |
| 137 | <p> | |
| 138 | <pre> | |
| 139 | gap> n := LibraryNearRing( TWGroup( 8, 2 ), 3 ); | |
| 140 | LibraryNearRing(8/2, 3) | |
| 141 | gap> gamma := NGroupByNearRingMultiplication( n ); | |
| 142 | < N-group of LibraryNearRing(8/2, 3) > | |
| 143 | gap> PrintTable( gamma ); | |
| 144 | Let: | |
| 145 | n0 := (()) | |
| 146 | n1 := ((3,4,5,6)) | |
| 147 | n2 := ((3,5)(4,6)) | |
| 148 | n3 := ((3,6,5,4)) | |
| 149 | n4 := ((1,2)) | |
| 150 | n5 := ((1,2)(3,4,5,6)) | |
| 151 | n6 := ((1,2)(3,5)(4,6)) | |
| 152 | n7 := ((1,2)(3,6,5,4)) | |
| 153 | -------------------------------------------------------------------- | |
| 154 | g0 := () | |
| 155 | g1 := (3,4,5,6) | |
| 156 | g2 := (3,5)(4,6) | |
| 157 | g3 := (3,6,5,4) | |
| 158 | g4 := (1,2) | |
| 159 | g5 := (1,2)(3,4,5,6) | |
| 160 | g6 := (1,2)(3,5)(4,6) | |
| 161 | g7 := (1,2)(3,6,5,4) | |
| 162 | ||
| 163 | N = LibraryNearRing(8/2, 3) acts on | |
| 164 | G = Group( [ (1,2), (3,4,5,6) ] ) | |
| 165 | from the right by the following action: | |
| 166 | ||
| 167 | | g0 g1 g2 g3 g4 g5 g6 g7 | |
| 168 | ------------------------------------ | |
| 169 | n0 | g0 g0 g0 g0 g0 g0 g0 g0 | |
| 170 | n1 | g0 g0 g0 g0 g0 g0 g0 g2 | |
| 171 | n2 | g0 g0 g0 g0 g0 g0 g0 g0 | |
| 172 | n3 | g0 g0 g0 g0 g0 g0 g0 g2 | |
| 173 | n4 | g0 g0 g0 g0 g0 g0 g0 g0 | |
| 174 | n5 | g0 g0 g0 g0 g0 g0 g0 g2 | |
| 175 | n6 | g0 g0 g0 g0 g0 g0 g0 g0 | |
| 176 | n7 | g0 g0 g0 g0 g0 g0 g0 g2 | |
| 177 | ||
| 178 | </pre> | |
| 179 | <p> | |
| 180 | <p> | |
| 181 | <h2><a name="SECT003">8.3 Functions for N-groups</a></h2> | |
| 182 | <p><p> | |
| 183 | <a name = "SSEC003.1"></a> | |
| 184 | <li><code>IsNGroup( </code><var>G</var><code> )</code> | |
| 185 | <p> | |
| 186 | For any group <var>G</var> the function <code>IsNGroup</code> tests whether there is a nearring | |
| 187 | defined that acts on <var>G</var>. | |
| 188 | <p> | |
| 189 | <a name = "SSEC003.2"></a> | |
| 190 | <li><code>NearRingActingOnNGroup( </code><var>G</var><code> )</code> | |
| 191 | <p> | |
| 192 | The function <code>NearRingActingOnNGroup</code> returns the nearring that acts on the | |
| 193 | N-group <var>G</var>. | |
| 194 | <p> | |
| 195 | <pre> | |
| 196 | gap> n := LibraryNearRing( TWGroup( 8, 2 ), 3 ); | |
| 197 | LibraryNearRing(8/2, 3) | |
| 198 | gap> gamma := NGroupByNearRingMultiplication( n ); | |
| 199 | < N-group of LibraryNearRing(8/2, 3) > | |
| 200 | gap> NearRingActingOnNGroup( gamma ); | |
| 201 | LibraryNearRing(8/2, 3) | |
| 202 | </pre> | |
| 203 | <p> | |
| 204 | <a name = "SSEC003.3"></a> | |
| 205 | <li><code>ActionOfNearRingOnNGroup( </code><var>G</var><code> )</code> | |
| 206 | <p> | |
| 207 | The function <code>ActionOfNearRingOnNGroup</code> returns the action of the nearring | |
| 208 | that acts on the N-group <var>G</var> as a 2-ary <font face="Gill Sans,Helvetica,Arial">GAP</font>-function. | |
| 209 | <p> | |
| 210 | <pre> | |
| 211 | gap> n := LibraryNearRing( TWGroup( 8, 2 ), 3 ); | |
| 212 | LibraryNearRing(8/2, 3) | |
| 213 | gap> gamma := NGroupByNearRingMultiplication( n ); | |
| 214 | < N-group of LibraryNearRing(8/2, 3) > | |
| 215 | gap> ActionOfNearRingOnNGroup( gamma ); | |
| 216 | function ( g, n ) ... end | |
| 217 | </pre> | |
| 218 | <p> | |
| 219 | <p> | |
| 220 | <h2><a name="SECT004">8.4 N-subgroups</a></h2> | |
| 221 | <p><p> | |
| 222 | <a name = "SSEC004.1"></a> | |
| 223 | <li><code>NSubgroup( </code><var>G</var><code>, </code><var>gens</var><code> )</code> | |
| 224 | <p> | |
| 225 | The function <code>NSubgroup</code> returns the N-subgroup of the N-group <var>G</var> | |
| 226 | generated by <var>gens</var>. | |
| 227 | <p> | |
| 228 | <a name = "SSEC004.2"></a> | |
| 229 | <li><code>NSubgroups( </code><var>G</var><code> )</code> | |
| 230 | <p> | |
| 231 | The function <code>NSubgroups</code> returns a list of all N-subgroups of the | |
| 232 | N-group <var>G</var>. | |
| 233 | <p> | |
| 234 | <a name = "SSEC004.3"></a> | |
| 235 | <li><code>IsNSubgroup( </code><var>G</var><code>, </code><var>S</var><code> )</code> | |
| 236 | <p> | |
| 237 | The function <code>IsNSubgroup</code> returns <code>true</code> iff <var>S</var> is an N-subgroup of | |
| 238 | <var>G</var>. | |
| 239 | <p> | |
| 240 | <p> | |
| 241 | <h2><a name="SECT005">8.5 N0-subgroups</a></h2> | |
| 242 | <p><p> | |
| 243 | <a name = "SSEC005.1"></a> | |
| 244 | <li><code>N0Subgroups( </code><var>G</var><code> )</code> | |
| 245 | <p> | |
| 246 | The function <code>N0Subgroups</code> returns a list of all <i>N</i><sub>0</sub>-subgroups | |
| 247 | of the N-group <var>G</var>. | |
| 248 | <p> | |
| 249 | <pre> | |
| 250 | gap> n := LibraryNearRing(GTW12_3,20465); | |
| 251 | LibraryNearRing(12/3, 20465) | |
| 252 | gap> ng := NGroupByNearRingMultiplication( n ); | |
| 253 | < N-group of LibraryNearRing(12/3, 20465) > | |
| 254 | gap> Length( N0Subgroups( ng ) ); | |
| 255 | 9 | |
| 256 | </pre> | |
| 257 | <p> | |
| 258 | <p> | |
| 259 | <h2><a name="SECT006">8.6 Ideals of N-groups</a></h2> | |
| 260 | <p><p> | |
| 261 | <a name = "SSEC006.1"></a> | |
| 262 | <li><code>NIdeal( </code><var>G</var><code>, </code><var>gens</var><code> )</code> | |
| 263 | <p> | |
| 264 | The function <code>NIdeal</code> returns the N-ideal of the N-group <var>G</var> generated | |
| 265 | by <var>gens</var>. | |
| 266 | <p> | |
| 267 | <a name = "SSEC006.2"></a> | |
| 268 | <li><code>NIdeals( </code><var>G</var><code> )</code> | |
| 269 | <p> | |
| 270 | The function <code>NGroupIdeals</code> returns a list of all ideals of the N-group <var>G</var>. | |
| 271 | <p> | |
| 272 | <pre> | |
| 273 | gap> n:=LibraryNearRing(GTW12_3,20465); | |
| 274 | LibraryNearRing(12/3, 20465) | |
| 275 | gap> ng := NGroupByNearRingMultiplication( n ); | |
| 276 | < N-group of LibraryNearRing(12/3, 20465) > | |
| 277 | gap> NIdeals( ng ); | |
| 278 | [ < N-group of LibraryNearRing(12/3, 20465) >, | |
| 279 | < N-group of LibraryNearRing(12/3, 20465) >, | |
| 280 | < N-group of LibraryNearRing(12/3, 20465) > ] | |
| 281 | </pre> | |
| 282 | <p> | |
| 283 | <a name = "SSEC006.3"></a> | |
| 284 | <li><code>IsNIdeal( </code><var>G</var><code>, </code><var>I</var><code> )</code> | |
| 285 | <p> | |
| 286 | The function <code>IsNIdeal</code> returns <code>true</code> iff <var>I</var> is an N-ideal of the | |
| 287 | N-group <var>G</var>. | |
| 288 | <p> | |
| 289 | <a name = "SSEC006.4"></a> | |
| 290 | <li><code>IsSimpleNGroup( </code><var>G</var><code> )</code> | |
| 291 | <p> | |
| 292 | The function <code>IsSimpleNGroup</code> returns <code>true</code> if <var>G</var> is a simple N-group | |
| 293 | and <code>false</code> otherwise. | |
| 294 | <p> | |
| 295 | <a name = "SSEC006.5"></a> | |
| 296 | <li><code>IsN0SimpleNGroup( </code><var>G</var><code> )</code> | |
| 297 | <p> | |
| 298 | The function <code>IsN0SimpleNGroup</code> returns <code>true</code> if the N-group <var>G</var> is | |
| 299 | <i>N</i><sub>0</sub>-simple and <code>false</code> otherwise. | |
| 300 | <p> | |
| 301 | <p> | |
| 302 | <h2><a name="SECT007">8.7 Special properties of N-groups</a></h2> | |
| 303 | <p><p> | |
| 304 | <a name = "SSEC007.1"></a> | |
| 305 | <li><code>IsCompatible( </code><var>G</var><code> )</code> | |
| 306 | <p> | |
| 307 | The function <code>IsCompatible</code> returns <code>true</code> if the N-group <var>G</var> is compatible | |
| 308 | and <code>false</code> otherwise. | |
| 309 | <p> | |
| 310 | <a name = "SSEC007.2"></a> | |
| 311 | <li><code>IsTameNGroup( </code><var>G</var><code> )</code> | |
| 312 | <p> | |
| 313 | The function <code>IsTameNGroup</code> returns <code>true</code> if <var>G</var> is a tame N-group | |
| 314 | and <code>false</code> otherwise. | |
| 315 | <p> | |
| 316 | <a name = "SSEC007.3"></a> | |
| 317 | <li><code>Is2TameNGroup( </code><var>G</var><code> )</code> | |
| 318 | <p> | |
| 319 | The function <code>Is2TameNGroup</code> returns <code>true</code> if the N-group <var>G</var> is 2-tame | |
| 320 | and <code>false</code> otherwise. | |
| 321 | <p> | |
| 322 | <a name = "SSEC007.4"></a> | |
| 323 | <li><code>Is3TameNGroup( </code><var>G</var><code> )</code> | |
| 324 | <p> | |
| 325 | The function <code>Is3TameNGroup</code> returns <code>true</code> if the N-group <var>G</var> is 3-tame | |
| 326 | and <code>false</code> otherwise. | |
| 327 | <p> | |
| 328 | <a name = "SSEC007.5"></a> | |
| 329 | <li><code>IsMonogenic( </code><var>G</var><code> )</code> | |
| 330 | <p> | |
| 331 | The function <code>IsMonogenic</code> returns <code>true</code> if the N-group <var>G</var> is monogenic | |
| 332 | and <code>false</code> otherwise. | |
| 333 | <p> | |
| 334 | <a name = "SSEC007.6"></a> | |
| 335 | <li><code>IsStronglyMonogenic( </code><var>G</var><code> )</code> | |
| 336 | <p> | |
| 337 | The function <code>IsStronglyMonogenic</code> returns <code>true</code> if the N-group <var>G</var> is | |
| 338 | strongly monogenic and <code>false</code> otherwise. | |
| 339 | <p> | |
| 340 | <a name = "SSEC007.7"></a> | |
| 341 | <li><code>TypeOfNGroup( </code><var>G</var><code> )</code> | |
| 342 | <p> | |
| 343 | The function <code>TypeOfNGroup</code> returns the type of a monogenic N-group <var>G</var>. If | |
| 344 | <var>N</var> is not monogenic or not of type 0, 1 or 2 it returns <code>fail</code>. | |
| 345 | <p> | |
| 346 | <pre> | |
| 347 | gap> n:=LibraryNearRing(GTW12_3,20465); | |
| 348 | LibraryNearRing(12/3, 20465) | |
| 349 | gap> ng := NGroupByNearRingMultiplication( n ); | |
| 350 | < N-group of LibraryNearRing(12/3, 20465) > | |
| 351 | gap> TypeOfNGroup( ng ); | |
| 352 | fail | |
| 353 | </pre> | |
| 354 | <p> | |
| 355 | <p> | |
| 356 | <h2><a name="SECT008">8.8 Noetherian quotients</a></h2> | |
| 357 | <p><p> | |
| 358 | <a name = "SSEC008.1"></a> | |
| 359 | <li><code>NoetherianQuotient( </code><var>nr</var><code>, </code><var>ngrp</var><code>, </code><var>target</var><code>, </code><var>source</var><code> )</code> | |
| 360 | <p> | |
| 361 | It is assumed that <var>source</var> and <var>target</var> are subsets of the <var>nr</var>-group | |
| 362 | <var>ngrp</var>. The function <code>NoetherianQuotient</code> computes the set of all | |
| 363 | elements <var>f</var> of <var>nr</var> such that <var>source</var>*<var>f</var> is a subset of <var>target</var>. | |
| 364 | If <var>target</var> is an <var>nr</var>-ideal of <var>ngrp</var>, the Noetherian quotient is | |
| 365 | returned as a near ring ideal, if <var>target</var> is an <var>nr</var>-subgroup of | |
| 366 | <var>ngrp</var>, a left ideal of <var>nr</var> is returned. Otherwise the result is a | |
| 367 | subset of <var>nr</var>. | |
| 368 | <p> | |
| 369 | In the following example we let a nearring act on its group reduct and | |
| 370 | compute the noetherian quotient (<i>I</i>,<i>I</i>)<sub><i>N</i></sub> for an ideal <i>I</i> of <i>N</i>. | |
| 371 | <p> | |
| 372 | <pre> | |
| 373 | gap> N := LibraryNearRing( GTW12_3, 100 ); | |
| 374 | LibraryNearRing(12/3, 100) | |
| 375 | gap> I := NearRingIdeals( N ); | |
| 376 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] | |
| 377 | gap> List(I,Size); | |
| 378 | [ 1, 6, 12 ] | |
| 379 | gap> NN := NGroupByNearRingMultiplication( N ); | |
| 380 | < N-group of LibraryNearRing(12/3, 100) > | |
| 381 | gap> NoetherianQuotient( N, NN, GroupReduct(I[2]), GroupReduct(I[2]) ); | |
| 382 | < nearring ideal > | |
| 383 | gap> Size(last); | |
| 384 | 12 | |
| 385 | </pre> | |
| 386 | <p> | |
| 387 | <p> | |
| 388 | <h2><a name="SECT009">8.9 Nearring radicals</a></h2> | |
| 389 | <p><p> | |
| 390 | <a name = "SSEC009.1"></a> | |
| 391 | <li><code>NuRadical( </code><var>nr</var><code>, </code><var>nu</var><code> )</code> | |
| 392 | <p> | |
| 393 | The function <code>NuRadical</code> has two arguments, a nearring <var>nr</var> and a number | |
| 394 | <var>nu</var> which must be one of <code>0</code>, <code>1/2</code>, <code>1</code> and <code>2</code>. It returns the | |
| 395 | <font face="symbol">n</font>-radical for <font face="symbol">n</font> = 0, 1/2, 1, 2 respectively. | |
| 396 | <p> | |
| 397 | <a name = "SSEC009.2"></a> | |
| 398 | <li><code>NuRadicals( </code><var>nr</var><code> )</code> | |
| 399 | <p> | |
| 400 | the function <code>NuRadicals</code> returns a record with the components <code>J_0</code>, <code>J1_2</code>, | |
| 401 | <code>J1</code> and <code>J2</code> with the corresponding radicals. | |
| 402 | <p> | |
| 403 | <pre> | |
| 404 | gap> f := LibraryNearRing( GTW8_4, 3 ); | |
| 405 | LibraryNearRing(8/4, 3) | |
| 406 | gap> NuRadicals( f ); | |
| 407 | rec( J2 := < nearring ideal >, J1 := < nearring ideal >, | |
| 408 | J1_2 := < nearring right ideal >, J0 := < nearring ideal > ) | |
| 409 | gap> NuRadical( f, 1/2 ); | |
| 410 | < nearring right ideal > | |
| 411 | gap> Size( NuRadical( f, 0 ) ); | |
| 412 | 8 | |
| 413 | gap> AsList( NuRadical( f, 1 ) ); | |
| 414 | [ (()), ((2,4)), ((1,2)(3,4)), ((1,2,3,4)), ((1,3)), ((1,3)(2,4)), | |
| 415 | ((1,4,3,2)), ((1,4)(2,3)) ] | |
| 416 | gap> NuRadical( f, 1/2 ) = NuRadical( f, 2 ); | |
| 417 | true | |
| 418 | </pre> | |
| 419 | <p> | |
| 420 | <p> | |
| 421 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP007.htm">Previous</a>] [<a href ="CHAP009.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 422 | <P> | |
| 423 | <address>SONATA manual<br>October 2018 | |
| 424 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 9 Fixed-point-free automorphism groups</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP008.htm">Previous</a>] [<a href ="CHAP010.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>9 Fixed-point-free automorphism groups</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP009.htm#SECT001">Fixed-point-free automorphism groups and Frobenius groups</a> | |
| 8 | <li> <A HREF="CHAP009.htm#SECT002">Fixed-point-free representations</a> | |
| 9 | <li> <A HREF="CHAP009.htm#SECT003">Fixed-point-free automorphism groups</a> | |
| 10 | </ol><p> | |
| 11 | <p> | |
| 12 | The functions described in this chapter are purely group-theoretic and | |
| 13 | are meant to provide solvable fixed-point-free automorphism groups acting on | |
| 14 | abelian groups (Frobenius groups with abelian Frobenius kernel and solvable | |
| 15 | Frobenius complement) | |
| 16 | for the construction of centralizer nearrings, planar nearrings, designs, | |
| 17 | and so on. | |
| 18 | <p> | |
| 19 | The classification of fixed-point-free automorphism groups in types I - IV | |
| 20 | follows Zassenhaus' papers and <a href="biblio.htm#Wolf:Spaces"><[>Wolf:Spaces</cite></a>]. | |
| 21 | The fixed-point-free automorphism groups acting on abelian groups are | |
| 22 | constructed from fixed-point-free representations as described in | |
| 23 | <a href="biblio.htm#Mayr:Representations"><[>Mayr:Representations</cite></a>]. | |
| 24 | <p> | |
| 25 | <p> | |
| 26 | <h2><a name="SECT001">9.1 Fixed-point-free automorphism groups and Frobenius groups</a></h2> | |
| 27 | <p><p> | |
| 28 | <a name = "SSEC001.1"></a> | |
| 29 | <li><code>IsFpfAutomorphismGroup( </code><var>phi</var><code>, </code><var>G</var><code> )</code> | |
| 30 | <p> | |
| 31 | An automorphism group <font face="symbol">F</font> of a group <i>G</i> acts fixed-point-free (fpf) on <i>G</i> | |
| 32 | if <font face="symbol">F</font> has more than 1 element and no automorphism in <font face="symbol">F</font> except the | |
| 33 | identity mapping has a fixed point besides the group identity of <i>G</i>. | |
| 34 | <p> | |
| 35 | <font face="symbol">F</font> is fpf on <i>G</i>, iff the semidirect product of | |
| 36 | <i>G</i> and <font face="symbol">F</font>, with <font face="symbol">F</font> acting naturally on <i>G</i>, is a Frobenius group. | |
| 37 | <p> | |
| 38 | The function <code>IsFpfAutomorphismGroup</code> returns the according value | |
| 39 | <code>true</code> or <code>false</code> for a group of automorphisms <var>phi</var> on the group <var>G</var>. | |
| 40 | <p> | |
| 41 | <pre> | |
| 42 | gap> C9 := CyclicGroup( 9 ); | |
| 43 | <pc group of size 9 with 2 generators> | |
| 44 | gap> a := GroupHomomorphismByFunction( C9, C9, x -> x^-1 );; | |
| 45 | gap> phi := Group( a );; | |
| 46 | gap> Size( phi ); | |
| 47 | 2 | |
| 48 | gap> IsFpfAutomorphismGroup( phi, C9 ); | |
| 49 | true | |
| 50 | </pre> | |
| 51 | <p> | |
| 52 | <a name = "SSEC001.2"></a> | |
| 53 | <li><code>FpfAutomorphismGroupsMaxSize( </code><var>G</var><code> )</code> | |
| 54 | <p> | |
| 55 | <code>FpfAutomorphismGroupsMaxSize</code> returns a list with integers <var>kmax</var> | |
| 56 | and <var>dmax</var> where <var>kmax</var> is an upper bound for the size of an fpf | |
| 57 | automorphism group on the group <var>G</var>; for example, the order of <var>G</var> is | |
| 58 | congruent to 1 modulo <var>kmax</var> and <var>kmax</var> is odd for nonabelian groups <var>G</var>. | |
| 59 | The order of any fpf automorphism group <var>phi</var> on <var>G</var> divides <var>kmax</var>. | |
| 60 | <p> | |
| 61 | Let <var>phi</var> be a metacyclic fpf automorphism group acting on <var>G</var>. | |
| 62 | Then <var>phi</var> has a cyclic normal subgroup whose index in <var>phi</var> divides <var>dmax</var>. | |
| 63 | Thus, if <var>dmax</var> is 1, then <var>G</var> admits cyclic fpf automorphism | |
| 64 | groups only. | |
| 65 | <p> | |
| 66 | <pre> | |
| 67 | gap> G := ElementaryAbelianGroup( 49 );; | |
| 68 | gap> FpfAutomorphismGroupsMaxSize( G ); | |
| 69 | [ 48, 2 ] | |
| 70 | gap> C15 := CyclicGroup( 15 );; | |
| 71 | gap> FpfAutomorphismGroupsMaxSize( C15 ); | |
| 72 | [ 2, 1 ] | |
| 73 | </pre> | |
| 74 | <p> | |
| 75 | <a name = "SSEC001.3"></a> | |
| 76 | <li><code>FrobeniusGroup( </code><var>phi</var><code>, </code><var>G</var><code> )</code> | |
| 77 | <p> | |
| 78 | <code>FrobeniusGroup</code> constructs the semidirect product of <var>G</var> with the | |
| 79 | fpf automorphism group <var>phi</var> of <var>G</var> with the multiplication | |
| 80 | (<i>a</i>,<i>g</i>)*(<i>b</i>,<i>h</i>)=(<i>ab</i>,<i>g</i><sup><i>a</i></sup><i>h</i>) by using the function <code>SemidirectProduct</code>. | |
| 81 | Thus a Frobenius group with Frobenius kernel <var>G</var> and Frobenius complement | |
| 82 | <var>phi</var> where the action of <var>phi</var> on <var>G</var> is the natural action of automorphisms | |
| 83 | on the group is returned. | |
| 84 | <p> | |
| 85 | The unique Frobenius group with kernel | |
| 86 | <i>G</i> = (<i>Z</i><sub>3</sub>)<sup>2</sup>×(<i>Z</i><sub>5</sub>)<sup>2</sup> | |
| 87 | and quaternion complement is constructed as follows: | |
| 88 | <p> | |
| 89 | <pre> | |
| 90 | gap> aux := FpfAutomorphismGroupsMetacyclic( [3,3,5,5], 4, -1 ); | |
| 91 | [ [ [ [ f1, f2, f3, f4 ] -> [ f1^2, f2^3, f3*f4, f3*f4^2 ], | |
| 92 | [ f1, f2, f3, f4 ] -> [ f2^4, f1, f4^2, f3 ] ] ], | |
| 93 | <pc group of size 225 with 4 generators> ] | |
| 94 | gap> phi := Group( aux[1][1] ); | |
| 95 | <group with 2 generators> | |
| 96 | gap> G := aux[2]; | |
| 97 | <pc group of size 225 with 4 generators> | |
| 98 | gap> FrobeniusGroup( phi, G ); | |
| 99 | <pc group of size 1800 with 7 generators> | |
| 100 | </pre> | |
| 101 | <p> | |
| 102 | <p> | |
| 103 | <h2><a name="SECT002">9.2 Fixed-point-free representations</a></h2> | |
| 104 | <p><p> | |
| 105 | <a name = "SSEC002.1"></a> | |
| 106 | <li><code>IsFpfRepresentation( </code><var>matrices</var><code>, </code><var>F</var><code> )</code> | |
| 107 | <p> | |
| 108 | Let <font face="symbol">p</font> be a representation of the group <font face="symbol">F</font> over the finite field <i>F</i>. | |
| 109 | If for all <font face="symbol">j</font> <font face="symbol">Î</font> <font face="symbol">F</font> except for the identity the matrix <font face="symbol">p</font>(<font face="symbol">j</font>) | |
| 110 | does not have 1 as an eigenvalue, then <font face="symbol">p</font> is said to be fpf. | |
| 111 | <p> | |
| 112 | Let <font face="symbol">p</font> be an fpf representation of <font face="symbol">F</font> over <i>F</i> with degree | |
| 113 | <i>d</i>. Then <font face="symbol">p</font> is faithful, the order of <font face="symbol">F</font> and the characteristic of | |
| 114 | <i>F</i> are coprime and <font face="symbol">p</font> is a sum of irreducible faithful fpf | |
| 115 | <i>F</i>-representations. | |
| 116 | The matrix group <font face="symbol">p</font>(<font face="symbol">F</font>) acts fpf on the vectorspace <i>F</i><sup><i>d</i></sup>. | |
| 117 | <p> | |
| 118 | For a list of <i>d</i>×<i>d</i> matrices, <var>matrices</var>, over the field <var>F</var>, | |
| 119 | the function <code>IsFpfRepresentation</code> returns <code>true</code> if the | |
| 120 | group generated by <var>matrices</var> acts fpf on the <i>d</i>-dimensional | |
| 121 | vectorspace over <var>F</var>, and <code>false</code> otherwise. | |
| 122 | <p> | |
| 123 | <pre> | |
| 124 | gap> F := GF(5);; | |
| 125 | gap> A := [[2,0],[0,3]]*One(F); | |
| 126 | [ [ Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^3 ] ] | |
| 127 | gap> IsFpfRepresentation( [A], F ); | |
| 128 | true | |
| 129 | </pre> | |
| 130 | <p> | |
| 131 | <a name = "SSEC002.2"></a> | |
| 132 | <li><code>DegreeOfIrredFpfRepCyclic( </code><var>p</var><code>, </code><var>m</var><code> )</code> | |
| 133 | <p> | |
| 134 | returns the degree of the irreducible fpf representations of | |
| 135 | the cyclic group of order <var>m</var> over GF(<var>p</var>), where <var>m</var> and <var>p</var> are coprime. | |
| 136 | <p> | |
| 137 | Note, that all irreducible fpf representations of the cyclic group | |
| 138 | of order <var>m</var> over GF(<var>p</var>) have the same degree, the multiplicative order | |
| 139 | of <var>p</var> modulo <var>m</var>, <code>OrderMod( p, m )</code>. | |
| 140 | <p> | |
| 141 | <pre> | |
| 142 | gap> DegreeOfIrredFpfRepCyclic( 5, 9 ); | |
| 143 | 6 | |
| 144 | </pre> | |
| 145 | <p> | |
| 146 | <a name = "SSEC002.3"></a> | |
| 147 | <li><code>DegreeOfIrredFpfRepMetacyclic( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code> )</code> | |
| 148 | <p> | |
| 149 | returns the degree of the irreducible fpf representations of | |
| 150 | the metacyclic group <font face="symbol">F</font> determined by parameters <var>m</var> and <var>r</var> over | |
| 151 | GF(<var>p</var>). If the parameters are not feasible, then an error is returned. | |
| 152 | See <code>FpfRepresentationsMetacyclic</code> for a presentation of this | |
| 153 | group. | |
| 154 | <p> | |
| 155 | All irreducible fpf representations of the metacyclic group | |
| 156 | over GF(<var>p</var>) have the same degree, namely the size of multiplicative group | |
| 157 | generated by <var>p</var> and <var>r</var> modulo <var>m</var>. | |
| 158 | <p> | |
| 159 | We determine the degree of the irreducible fpf representation of the | |
| 160 | quaternion group over GF(5): | |
| 161 | <p> | |
| 162 | <pre> | |
| 163 | gap> DegreeOfIrredFpfRepMetacyclic( 5, 4, -1 ); | |
| 164 | 2 | |
| 165 | </pre> | |
| 166 | <p> | |
| 167 | <a name = "SSEC002.4"></a> | |
| 168 | <li><code>DegreeOfIrredFpfRep2( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code>, </code><var>k</var><code> )</code> | |
| 169 | <p> | |
| 170 | returns the degree of the irreducible fpf representations of | |
| 171 | the type-II-group <font face="symbol">F</font> determined by parameters <var>m</var>, <var>r</var>, and <var>k</var> over | |
| 172 | GF(<var>p</var>). If the parameters are not feasible or if the parameters describe | |
| 173 | the presentation of a metacyclic group, then an error is returned. | |
| 174 | See <code>FpfRepresentations2</code> for a presentation of this group. | |
| 175 | <p> | |
| 176 | All irreducible fpf representations of <font face="symbol">F</font> over GF(<var>p</var>) have | |
| 177 | the same degree, namely the size of the multiplicative group | |
| 178 | generated by <var>p</var>, <var>r</var>, and <var>k</var> modulo <var>m</var>. | |
| 179 | <p> | |
| 180 | We determine the degree of the irreducible fpf representation of the smallest, | |
| 181 | not metacyclic type-2-group (order 120) over the field GF(7): | |
| 182 | <p> | |
| 183 | <pre> | |
| 184 | gap> DegreeOfIrredFpfRep2( 7, 30, 11, -1 ); | |
| 185 | 8 | |
| 186 | </pre> | |
| 187 | <p> | |
| 188 | <a name = "SSEC002.5"></a> | |
| 189 | <li><code>DegreeOfIrredFpfRep3( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code> )</code> | |
| 190 | <p> | |
| 191 | returns the degree of the irreducible fpf representations of | |
| 192 | the type-III-group <font face="symbol">F</font> determined by parameters <var>m</var> and <var>r</var> over | |
| 193 | GF(<var>p</var>). If the parameters are not feasible, then an error is returned. | |
| 194 | See <code>FpfRepresentations3</code> for a presentation of this | |
| 195 | group. | |
| 196 | <p> | |
| 197 | All irreducible fpf representations of this group | |
| 198 | over GF(<var>p</var>) have the same degree. | |
| 199 | <p> | |
| 200 | We determine the degree of the irreducible fpf representation of SL(2,3) | |
| 201 | over GF(5): | |
| 202 | <p> | |
| 203 | <pre> | |
| 204 | gap> DegreeOfIrredFpfRep3( 5, 3, 1 ); | |
| 205 | 2 | |
| 206 | </pre> | |
| 207 | <p> | |
| 208 | <a name = "SSEC002.6"></a> | |
| 209 | <li><code>DegreeOfIrredFpfRep4( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code>, </code><var>k</var><code> )</code> | |
| 210 | <p> | |
| 211 | returns the degree of the irreducible fpf representations of | |
| 212 | the type-IV-group <font face="symbol">F</font> determined by parameters <var>m</var>, <var>r</var>, and <var>k</var> over | |
| 213 | GF(<var>p</var>). If the parameters are not feasible, then an error is returned. | |
| 214 | See <code>FpfRepresentations4</code> for a presentation of this group. | |
| 215 | <p> | |
| 216 | All irreducible fpf representations of <font face="symbol">F</font> over GF(<var>p</var>) have | |
| 217 | the same degree. | |
| 218 | <p> | |
| 219 | We determine the degree of the irreducible fpf representation of the smallest | |
| 220 | type-4-group, the binary octahedral group of order 48, over <i>GF</i>(5): | |
| 221 | <p> | |
| 222 | <pre> | |
| 223 | gap> DegreeOfIrredFpfRep4( 5, 3, 1, -1 ); | |
| 224 | 4 | |
| 225 | </pre> | |
| 226 | <p> | |
| 227 | <a name = "SSEC002.7"></a> | |
| 228 | <li><code>FpfRepresentationsCyclic( </code><var>p</var><code>, </code><var>m</var><code> )</code> | |
| 229 | <p> | |
| 230 | Let <i>a</i> generate a cyclic group of order <var>m</var>. | |
| 231 | For <var>p</var> and <var>m</var> coprime <code>FpfRepresentationsCyclic</code> | |
| 232 | returns a list of matrices { <i>A</i><sup><i>i</i></sup> <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over GF(<var>p</var>) | |
| 233 | as well as the list <i>indexlist</i>. | |
| 234 | For all <i>i</i> in <i>indexlist</i> the representation <i>a</i> <font face="symbol">®</font> <i>A</i><sup><i>i</i></sup> | |
| 235 | is irreducible and fpf. | |
| 236 | The <i>A</i><sup><i>i</i></sup> with <i>i</i> in <i>indexlist</i> describe all irreducible fpf | |
| 237 | representations up to equivalence; each irreducible fpf | |
| 238 | representation is equivalent to one <i>a</i> <font face="symbol">®</font> <i>A</i><sup><i>i</i></sup> and no two representations | |
| 239 | <i>a</i> <font face="symbol">®</font> <i>A</i><sup><i>i</i></sup>, <i>a</i> <font face="symbol">®</font> <i>A</i><sup><i>j</i></sup> with <i>i</i> <font face="symbol">¹</font> <i>j</i> and <i>i</i>,<i>j</i> in <i>indexlist</i> are | |
| 240 | equivalent. | |
| 241 | <p> | |
| 242 | Note, that every faithful irreducible representation of a cyclic group | |
| 243 | is fpf. The number of nonequivalent faithful irreducible | |
| 244 | representations over GF(<var>p</var>) is given as <font face="symbol">f</font>(<i>m</i>)/<i>d</i>, where the degree <i>d</i> is | |
| 245 | given as the multiplicative order of <var>p</var> modulo <var>m</var> and <font face="symbol">f</font>(<i>m</i>) denotes | |
| 246 | the number of residues coprime to <i>m</i>. | |
| 247 | <p> | |
| 248 | We determine the irreducible matrix representations of the cyclic group of | |
| 249 | size 8 over <i>GF</i>(5): | |
| 250 | <p> | |
| 251 | <pre> | |
| 252 | gap> aux := FpfRepresentationsCyclic( 5, 8 ); | |
| 253 | [ [ [ [ Z(5)^3, Z(5)^2 ], [ Z(5), Z(5) ] ], | |
| 254 | [ [ Z(5)^2, Z(5) ], [ Z(5)^0, Z(5)^0 ] ] ], [ 1, 7 ] ] | |
| 255 | gap> mats := aux[1]; | |
| 256 | [ [ [ Z(5)^3, Z(5)^2 ], [ Z(5), Z(5) ] ], | |
| 257 | [ [ Z(5)^2, Z(5) ], [ Z(5)^0, Z(5)^0 ] ] ] | |
| 258 | gap> indexlist := aux[2]; | |
| 259 | [ 1, 7 ] | |
| 260 | </pre> | |
| 261 | <p> | |
| 262 | <a name = "SSEC002.8"></a> | |
| 263 | <li><code>FpfRepresentationsMetacyclic( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code> )</code> | |
| 264 | <p> | |
| 265 | Let <font face="symbol">F</font> be a metacyclic group (i.e., <font face="symbol">F</font> has a cyclic normal subgroup | |
| 266 | with cyclic factor) admitting an fpf representation. Then <font face="symbol">F</font> | |
| 267 | fulfills one of the following two presentations, I or II. Both presentations | |
| 268 | are determined by integers <i>m</i> and <i>r</i> satisfying certain conditions: | |
| 269 | <p> | |
| 270 | Type I. Presentation of an fpf metacyclic group <font face="symbol">F</font> with all | |
| 271 | Sylow subgroups cyclic. | |
| 272 | Let <i>m</i> and <i>r</i> satisfy the following conditions: | |
| 273 | <p> | |
| 274 | <dl compact> | |
| 275 | <dt>(a)<dd><i>m</i> and <i>r</i> are coprime. | |
| 276 | <dt>(b)<dd>Let <i>n</i> be the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 277 | Then each prime divisor of <i>n</i> divides <i>m</i>. | |
| 278 | <dt>(c)<dd>Let <i>m</i><font face="symbol">¢</font> be maximal such that <i>m</i><font face="symbol">¢</font> divides <i>m</i> and <i>m</i><font face="symbol">¢</font> is coprime | |
| 279 | to <i>n</i>. Then <i>r</i> = 1 mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>). | |
| 280 | </dl> | |
| 281 | <p> | |
| 282 | Type II. Presentation of an fpf metacyclic group <font face="symbol">F</font> with | |
| 283 | generalized quaternion 2-Sylow subgroup. | |
| 284 | Let <i>m</i> and <i>r</i> satisfy the following conditions: | |
| 285 | <p> | |
| 286 | <dl compact> | |
| 287 | <dt>(a)<dd><i>m</i> and <i>r</i> are coprime. | |
| 288 | <dt>(b)<dd>Let <i>n</i> be the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 289 | Then <i>n</i> is 2 times an odd number and each prime divisor of <i>n</i> divides <i>m</i>. | |
| 290 | <dt>(c)<dd>Let <i>s</i> be maximal such that 2<sup><i>s</i></sup> divides <i>m</i>. Then 2<sup><i>s</i></sup> <font face="symbol">³</font> 4 | |
| 291 | and <i>r</i> = <font face="symbol">-</font>1 mod 2<sup><i>s</i></sup>. | |
| 292 | <dt>(d)<dd>Let <i>m</i><font face="symbol">¢</font> be maximal such that <i>m</i><font face="symbol">¢</font> divides <i>m</i>/2 and <i>m</i><font face="symbol">¢</font> is | |
| 293 | coprime to <i>n</i>/2. Then <i>r</i> = 1 mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>). | |
| 294 | </dl> | |
| 295 | <p> | |
| 296 | Then the group <font face="symbol">F</font> with 2 generators <i>a</i>,<i>b</i> satisfying the relations | |
| 297 | <i>a</i><sup><i>m</i></sup> = 1, <i>b</i><sup><i>n</i></sup> = <i>a</i><sup><i>m</i><font face="symbol">¢</font></sup>, <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup> | |
| 298 | is metacyclic and fpf and has size <i>mn</i>. | |
| 299 | <p> | |
| 300 | A group satisfying presentation I is of type I in the notation of Zassenhaus, | |
| 301 | Wolf; presentation II gives a type-II-group. | |
| 302 | <p> | |
| 303 | Let <var>m</var>, <var>r</var> be as above, and let <var>p</var> coprime to <var>m</var>. | |
| 304 | Additionally, we require that <var>m</var> does not divide <var>r</var>-1. (Otherwise, | |
| 305 | <font face="symbol">F</font> = <font face="symbol">á</font><i>a</i>,<i>b</i> <font face="symbol">|</font> <i>a</i><sup><i>m</i></sup> = 1, <i>b</i><sup><i>n</i></sup> = <i>a</i><sup><i>m</i><font face="symbol">¢</font></sup>, <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup> <font face="symbol">ñ</font> | |
| 306 | would be cyclic.) Then | |
| 307 | <code>FpfRepresentationsMetacyclic</code> | |
| 308 | returns a list of matrices { (<i>A</i><sup><i>i</i></sup>,<i>B</i><sub><i>i</i></sub>) <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over GF(<var>p</var>) | |
| 309 | as well as the list <i>indexlist</i>. The GF(<var>p</var>)-representations determined by | |
| 310 | <i>a</i> <font face="symbol">®</font> <i>A</i><sup><i>i</i></sup> and <i>b</i> <font face="symbol">®</font> <i>B</i><sub><i>i</i></sub> are all irreducible and fpf | |
| 311 | representations of | |
| 312 | <font face="symbol">F</font> = <font face="symbol">á</font><i>a</i>,<i>b</i> <font face="symbol">|</font> <i>a</i><sup><i>m</i></sup> = 1, <i>b</i><sup><i>n</i></sup> = <i>a</i><sup><i>m</i><font face="symbol">¢</font></sup>, <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup> <font face="symbol">ñ</font> | |
| 313 | up to equivalence. | |
| 314 | <p> | |
| 315 | We determine the irreducible matrix representation of the quaternion group | |
| 316 | (parameters <i>m</i> = 4, <i>r</i> = <font face="symbol">-</font>1) over <i>GF</i>(7): | |
| 317 | <p> | |
| 318 | <pre> | |
| 319 | gap> aux := FpfRepresentationsMetacyclic( 7, 4, -1 ); | |
| 320 | [ [ [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 321 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ] ] ], [ 1 ] ] | |
| 322 | gap> mats := aux[1]; | |
| 323 | [ [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 324 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ] ] ] | |
| 325 | </pre> | |
| 326 | <p> | |
| 327 | <a name = "SSEC002.9"></a> | |
| 328 | <li><code>FpfRepresentations2( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code>, </code><var>k</var><code> )</code> | |
| 329 | <p> | |
| 330 | The presentation of a type-II-group which is not metacyclic is determined by | |
| 331 | integers <i>m</i>,<i>r</i>,<i>k</i> satisfying the following conditions: | |
| 332 | <p> | |
| 333 | <dl compact> | |
| 334 | <dt>(a)<dd><i>m</i> and <i>r</i> are coprime, <i>m</i> and <i>k</i> are coprime. | |
| 335 | <dt>(b)<dd>Let <i>n</i> be the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 336 | Then <i>n</i> is 2 times an odd number and each prime divisor of <i>n</i> divides <i>m</i>. | |
| 337 | <dt>(c)<dd>Let <i>m</i><font face="symbol">¢</font> be maximal such that <i>m</i><font face="symbol">¢</font> divides <i>m</i> and <i>m</i><font face="symbol">¢</font> is coprime | |
| 338 | to <i>n</i>. Then <i>r</i> = 1 mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>). | |
| 339 | <dt>(d)<dd>Let 2<sup><i>s</i><font face="symbol">-</font>1</sup> be maximal such that 2<sup><i>s</i><font face="symbol">-</font>1</sup> divides <i>m</i>. Define | |
| 340 | <i>l</i> = <font face="symbol">-</font>1 mod 2<sup><i>s</i><font face="symbol">-</font>1</sup> and <i>l</i> = 1 mod (<i>nm</i>/(2<sup><i>s</i><font face="symbol">-</font>1</sup><i>m</i><font face="symbol">¢</font>)). | |
| 341 | Then <i>k</i> = <i>l</i> mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>). | |
| 342 | <dt>(e)<dd>The multiplicative order of <i>k</i> modulo <i>m</i> equals 2 and | |
| 343 | <i>k</i> <font face="symbol">¹</font> <i>r</i><sup>(<i>n</i>/2)</sup> mod <i>m</i>. | |
| 344 | </dl> | |
| 345 | <p> | |
| 346 | Then the group <font face="symbol">F</font> with generators <i>a</i>,<i>b</i>,<i>q</i> satisfying the | |
| 347 | relations | |
| 348 | <i>a</i><sup><i>m</i></sup> = 1, <i>b</i><sup><i>n</i></sup> = <i>a</i><sup><i>m</i><font face="symbol">¢</font></sup>, <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup> | |
| 349 | and furthermore | |
| 350 | <i>q</i><sup><font face="symbol">-</font>1</sup><i>a</i> <i>q</i> = <i>a</i><sup><i>k</i></sup>, <i>q</i><sup><font face="symbol">-</font>1</sup><i>b</i> <i>q</i> = <i>b</i><sup><i>l</i></sup> is fpf | |
| 351 | of type II and has size 2<i>mn</i>. | |
| 352 | <p> | |
| 353 | <i>a</i>,<i>b</i> generate a metacyclic group with all Sylow subgroups cyclic | |
| 354 | (see conditions (a), (b), (c)) of index 2 in <font face="symbol">F</font>. | |
| 355 | <p> | |
| 356 | For <var>m</var>, <var>r</var>, <var>k</var> as above and <var>p</var> coprime to <var>m</var> | |
| 357 | <code>FpfRepresentations2</code> | |
| 358 | returns a list of matrices { (<i>A</i><sub><i>i</i></sub>,<i>B</i><sub><i>i</i></sub>,<i>Q</i><sub><i>i</i></sub>) <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over | |
| 359 | GF(<var>p</var>) as well as the list <i>indexlist</i>. The GF(<var>p</var>)-representations | |
| 360 | determined by <i>a</i> <font face="symbol">®</font> <i>A</i><sub><i>i</i></sub>, <i>b</i> <font face="symbol">®</font> <i>B</i><sub><i>i</i></sub> and <i>q</i> <font face="symbol">®</font> <i>Q</i><sub><i>i</i></sub> are all | |
| 361 | irreducible, fpf representations of <font face="symbol">F</font> upto equivalence. | |
| 362 | <p> | |
| 363 | We determine the irreducible matrix representations of the smallest | |
| 364 | type-II-group which is not metacyclic (parameters m = 30, r = 11, k = -1, | |
| 365 | size 120) over the field GF(11) and obtain 2 nonequivalent fpf representations, | |
| 366 | each of degree 4: | |
| 367 | <p> | |
| 368 | <pre> | |
| 369 | gap> DegreeOfIrredFpfRep2( 11, 30, 11, -1 ); | |
| 370 | 4 | |
| 371 | gap> aux := FpfRepresentations2( 11, 30, 11, -1 ); | |
| 372 | [ [ [ <block matrix of dimensions (2*2)x(2*2)>, | |
| 373 | <block matrix of dimensions (2*2)x(2*2)>, | |
| 374 | <block matrix of dimensions (2*2)x(2*2)> ], | |
| 375 | [ <block matrix of dimensions (2*2)x(2*2)>, | |
| 376 | <block matrix of dimensions (2*2)x(2*2)>, | |
| 377 | <block matrix of dimensions (2*2)x(2*2)> ] ], [ 1, 13 ] ] | |
| 378 | </pre> | |
| 379 | <p> | |
| 380 | <a name = "SSEC002.10"></a> | |
| 381 | <li><code>FpfRepresentations3( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code> )</code> | |
| 382 | <p> | |
| 383 | A group <font face="symbol">F</font> admitting an fpf representation is said to be of | |
| 384 | type III if <font face="symbol">F</font> is the semidirect product of the quaternion group | |
| 385 | and a metacyclic fpf group <i>H</i> of odd size, with the quaternion | |
| 386 | group normal and <i>H</i> permuting the 3 subgroups of order 4. | |
| 387 | <p> | |
| 388 | The presentation of a type-III-group is determined by integers <i>m</i> and <i>r</i>, | |
| 389 | describing the metacyclic group <i>H</i> and its action on the normal quaternion | |
| 390 | subgroup. The following conditions have to be satisfied for <i>m</i>,<i>r</i>: | |
| 391 | <p> | |
| 392 | <dl compact> | |
| 393 | <dt>(a)<dd>3 divides <i>m</i>; <i>m</i> is odd; <i>m</i> and <i>r</i> are coprime. | |
| 394 | <dt>(b)<dd>Let <i>n</i> be the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 395 | Then each prime divisor of <i>n</i> divides <i>m</i>. | |
| 396 | <dt>(c)<dd>Let <i>m</i><font face="symbol">¢</font> be maximal such that <i>m</i><font face="symbol">¢</font> divides <i>m</i> and <i>m</i><font face="symbol">¢</font> is coprime | |
| 397 | to <i>n</i>. Then <i>r</i> = 1 mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>). | |
| 398 | </dl> | |
| 399 | <p> | |
| 400 | Let <i>p</i>,<i>q</i> with relations <i>p</i><sup>4</sup> = 1, <i>q</i><sup>2</sup> = <i>p</i><sup>2</sup>, <i>q</i><sup><font face="symbol">-</font>1</sup><i>pq</i> = <i>p</i><sup><font face="symbol">-</font>1</sup> generate | |
| 401 | the quaternion group. Let <i>a</i>,<i>b</i> generate a metacyclic group | |
| 402 | determined by <i>m</i> and <i>r</i> (See <code>FpfRepresentationsMetacyclic</code>). | |
| 403 | <p> | |
| 404 | If 3 divides <i>n</i>, then let <i>a</i> commute with <i>p</i>,<i>q</i> and let | |
| 405 | <i>b</i><sup><font face="symbol">-</font>1</sup><i>pb</i> = <i>q</i>, <i>b</i><sup><font face="symbol">-</font>1</sup><i>qb</i> = <i>pq</i>. | |
| 406 | <p> | |
| 407 | If 3 does not divide <i>n</i>, then let <i>b</i> commute with <i>p</i>,<i>q</i> and let | |
| 408 | <i>a</i><sup><font face="symbol">-</font>1</sup><i>pa</i> = <i>q</i>, <i>a</i><sup><font face="symbol">-</font>1</sup><i>qa</i> = <i>pq</i> | |
| 409 | <p> | |
| 410 | Then the group <font face="symbol">F</font> with generators <i>p</i>,<i>q</i>,<i>a</i>,<i>b</i> is of type III and | |
| 411 | has size 8<i>mn</i>. | |
| 412 | <p> | |
| 413 | For <i>r</i> <font face="symbol">¹</font> 1 mod <i>m</i>, <code>FpfRepresentations3</code> returns a list of matrices | |
| 414 | { (<i>P</i>, <i>Q</i>, <i>A</i><sub><i>i</i></sub>,<i>B</i><sub><i>i</i></sub>) <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over GF(<var>p</var>) as well as the list | |
| 415 | <i>indexlist</i>. | |
| 416 | <p> | |
| 417 | For <i>r</i> = 1 mod <i>m</i>, the group <i>H</i> is cyclic and <code>FpfRepresentations3</code> returns | |
| 418 | { (<i>P</i>, <i>Q</i>, <i>A</i><sub><i>i</i></sub>) <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over GF(<var>p</var>) and <i>indexlist</i>. | |
| 419 | <p> | |
| 420 | The GF(<var>p</var>)-representations | |
| 421 | determined by <i>p</i> <font face="symbol">®</font> <i>P</i>, <i>q</i> <font face="symbol">®</font> <i>Q</i> and <i>a</i> <font face="symbol">®</font> <i>A</i><sub><i>i</i></sub>, <i>b</i> <font face="symbol">®</font> <i>B</i><sub><i>i</i></sub> | |
| 422 | are all irreducible, fpf representations of <font face="symbol">F</font> upto equivalence. | |
| 423 | <p> | |
| 424 | We determine the irreducible matrix representation of the smallest | |
| 425 | type-III-group, namely SL(2,3), (parameters m = 3, r = 1, size 24) over the | |
| 426 | field GF(5): | |
| 427 | <p> | |
| 428 | <pre> | |
| 429 | gap> aux := FpfRepresentations3( 5, 3, 1 ); | |
| 430 | [ [ [ [ [ Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^3 ] ], | |
| 431 | [ [ 0*Z(5), Z(5)^2 ], [ Z(5)^0, 0*Z(5) ] ], | |
| 432 | [ [ Z(5)^3, Z(5)^0 ], [ Z(5), Z(5)^0 ] ] ] ], [ 1 ] ] | |
| 433 | </pre> | |
| 434 | <p> | |
| 435 | <a name = "SSEC002.11"></a> | |
| 436 | <li><code>FpfRepresentations4( </code><var>p</var><code>, </code><var>m</var><code>, </code><var>r</var><code>, </code><var>k</var><code> )</code> | |
| 437 | <p> | |
| 438 | A group <font face="symbol">F</font> = <font face="symbol">á</font><i>p</i>,<i>q</i>,<i>a</i>,<i>b</i>,<i>z</i><font face="symbol">ñ</font> admitting an fpf | |
| 439 | representation is said to be of type IV, if it has a normal subgroup | |
| 440 | <i>H</i> = <font face="symbol">á</font><i>p</i>,<i>q</i>,<i>a</i>,<i>b</i><font face="symbol">ñ</font> of type III and index 2. | |
| 441 | <p> | |
| 442 | The presentation of a type-IV-group is determined by integers <i>m</i>,<i>r</i>,<i>k</i> | |
| 443 | satisfying the following conditions: | |
| 444 | <p> | |
| 445 | <dl compact> | |
| 446 | <dt>(a)<dd>Let <i>s</i> be maximal such that 3<sup><i>s</i></sup> divides <i>m</i>. Then | |
| 447 | <i>s</i> <font face="symbol">³</font> 1; <i>m</i> is odd; <i>m</i> and <i>r</i> are coprime. | |
| 448 | <dt>(b)<dd>Let <i>n</i> be the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 449 | Then 3 does not divide <i>n</i>; each prime divisor of <i>n</i> divides <i>m</i>. | |
| 450 | <dt>(c)<dd>Let <i>m</i><font face="symbol">¢</font> be maximal such that <i>m</i><font face="symbol">¢</font> divides <i>m</i> and <i>m</i><font face="symbol">¢</font> is coprime | |
| 451 | to <i>n</i>. Then <i>r</i> = 1 mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>). | |
| 452 | <dt>(d)<dd><i>k</i> = <font face="symbol">-</font>1 mod 3<sup><i>s</i></sup>, <i>k</i> = 1 mod (<i>m</i>/<i>m</i><font face="symbol">¢</font>) and <i>k</i><sup>2</sup> = 1 modulo <i>m</i>. | |
| 453 | </dl> | |
| 454 | <p> | |
| 455 | Let <i>p</i>,<i>q</i>,<i>a</i>,<i>b</i> generate a type-III-group determined by <i>m</i>,<i>r</i> with relations as | |
| 456 | given in Section <code>FpfRepresentations3</code>. Additionally, let | |
| 457 | <i>z</i><sup>2</sup> = <i>p</i><sup>2</sup>, <i>z</i><sup><font face="symbol">-</font>1</sup><i>pz</i> = <i>qp</i>, <i>z</i><sup><font face="symbol">-</font>1</sup><i>qz</i> = <i>q</i><sup><font face="symbol">-</font>1</sup> and | |
| 458 | <i>z</i><sup><font face="symbol">-</font>1</sup><i>a</i> <i>z</i> = <i>a</i><sup><i>k</i></sup>,<i>z</i><sup><font face="symbol">-</font>1</sup><i>b</i> <i>z</i> = <i>b</i>. | |
| 459 | <p> | |
| 460 | Then the group <font face="symbol">F</font> with generators <i>p</i>,<i>q</i>,<i>a</i>,<i>b</i> and <i>z</i> is of type | |
| 461 | IV and has size 16<i>mn</i>. | |
| 462 | <p> | |
| 463 | For <i>r</i> <font face="symbol">¹</font> 1 mod <i>m</i>, <code>FpfRepresentations4</code> returns a list of matrices | |
| 464 | { (<i>P</i>, <i>Q</i>, <i>A</i><sub><i>i</i></sub>,<i>B</i><sub><i>i</i></sub>, <i>Z</i><sub><i>i</i></sub>) <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over GF(<var>p</var>) as well as the | |
| 465 | list <i>indexlist</i>. | |
| 466 | <p> | |
| 467 | For <i>r</i> = 1 mod <i>m</i>, the function <code>FpfRepresentations4</code> returns | |
| 468 | { (<i>P</i>, <i>Q</i>, <i>A</i><sub><i>i</i></sub>, <i>Z</i><sub><i>i</i></sub>) <font face="symbol">|</font> <i>i</i> in <i>indexlist</i> } over GF(<var>p</var>) and <i>indexlist</i>. | |
| 469 | <p> | |
| 470 | The GF(<var>p</var>)-representations | |
| 471 | determined by <i>p</i> <font face="symbol">®</font> <i>P</i>, <i>q</i> <font face="symbol">®</font> <i>Q</i> and | |
| 472 | <i>a</i> <font face="symbol">®</font> <i>A</i><sub><i>i</i></sub>, <i>b</i> <font face="symbol">®</font> <i>B</i><sub><i>i</i></sub>, <i>z</i> <font face="symbol">®</font> <i>Z</i><sub><i>i</i></sub> | |
| 473 | are all irreducible, fpf representations of <font face="symbol">F</font> upto equivalence. | |
| 474 | <p> | |
| 475 | We determine the 2 nonequivalent irreducible matrix representations of the | |
| 476 | smallest type-IV-group (binary octahedral group, m = 3, r = 1, k = -1, size 48) | |
| 477 | over the field GF(7): | |
| 478 | <p> | |
| 479 | <pre> | |
| 480 | gap> aux := FpfRepresentations4( 7, 3, 1, -1 ); | |
| 481 | [ [ [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 482 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ], | |
| 483 | [ [ Z(7)^2, 0*Z(7) ], [ Z(7)^0, Z(7)^4 ] ], | |
| 484 | [ [ Z(7)^5, Z(7) ], [ Z(7), Z(7)^2 ] ] ], | |
| 485 | [ [ [ Z(7)^2, Z(7) ], [ Z(7), Z(7)^5 ] ], | |
| 486 | [ [ 0*Z(7), Z(7)^3 ], [ Z(7)^0, 0*Z(7) ] ], | |
| 487 | [ [ Z(7)^2, 0*Z(7) ], [ Z(7)^0, Z(7)^4 ] ], | |
| 488 | [ [ Z(7)^2, Z(7)^4 ], [ Z(7)^4, Z(7)^5 ] ] ] ], | |
| 489 | [ [ 1, 1 ], [ -1, 1 ] ] ] | |
| 490 | </pre> | |
| 491 | <p> | |
| 492 | <p> | |
| 493 | <h2><a name="SECT003">9.3 Fixed-point-free automorphism groups</a></h2> | |
| 494 | <p><p> | |
| 495 | <a name = "SSEC003.1"></a> | |
| 496 | <li><code>FpfAutomorphismGroupsCyclic( </code><var>ints</var><code>, </code><var>m</var><code> )</code> | |
| 497 | <p> | |
| 498 | If <code>AbelianGroup(</code><var>ints</var><code>)</code> admits a cyclic fpf automorphism group of size | |
| 499 | <var>m</var>, then <code>FpfAutomorphismGroupsCyclic</code> determines one representative for | |
| 500 | each conjugacy class of such fpf automorphism groups. Conjugacy is determined | |
| 501 | within the whole automorphism group of <code>AbelianGroup(</code><var>ints</var><code>)</code>. | |
| 502 | <p> | |
| 503 | <var>ints</var> has to be a list of prime power integers and is sorted in the | |
| 504 | function, according to the order | |
| 505 | <i>p</i><sup><i>i</i></sup> <font face="symbol">£</font> <i>q</i><sup><i>j</i></sup> <font face="symbol">Û</font> <i>p</i> < <i>q</i> or (<i>p</i>=<i>q</i> and <i>j</i> < <i>i</i>). | |
| 506 | <p> | |
| 507 | <code>AbelianGroup(</code><var>ints</var><code>)</code> admits a cyclic fpf automorphism group | |
| 508 | of size <var>m</var> iff the multiplicity of each prime power <i>p</i><sup><i>i</i></sup> in <var>ints</var> | |
| 509 | is divisible by <code>DegreeOfIrredFpfRepCyclic( p, m )</code>. | |
| 510 | <p> | |
| 511 | A list of generators of the nonconjugate fpf automorphism groups is returned | |
| 512 | together with the group <code>AbelianGroup(</code><var>ints</var><code>)</code>, on which the automorphisms act. | |
| 513 | Here <var>ints</var> is sorted with the order above. | |
| 514 | <p> | |
| 515 | The generators, <var>as</var>, of the 2 nonconjugate cyclic fpf | |
| 516 | automorphism groups of order 4 on <i>Z</i><sub>25</sub>×<i>Z</i><sub>5</sub> are computed | |
| 517 | as follows: | |
| 518 | <p> | |
| 519 | <pre> | |
| 520 | gap> aux := FpfAutomorphismGroupsCyclic( [25,5], 4 ); | |
| 521 | [ [ [ f1, f3 ] -> [ f1^2*f2, f3^2 ], | |
| 522 | [ f1, f3 ] -> [ f1^2*f2, f3^3 ] ], | |
| 523 | <pc group of size 125 with 2 generators> ] | |
| 524 | gap> as := aux[1]; | |
| 525 | [ [ f1, f3 ] -> [ f1^2*f2, f3^2 ], [ f1, f3 ] -> [ f1^2*f2, f3^3 ] ] | |
| 526 | gap> G := aux[2]; | |
| 527 | <pc group of size 125 with 2 generators> | |
| 528 | </pre> | |
| 529 | <p> | |
| 530 | <a name = "SSEC003.2"></a> | |
| 531 | <li><code>FpfAutomorphismGroupsMetacyclic( </code><var>ints</var><code>, </code><var>m</var><code>, </code><var>r</var><code> )</code> | |
| 532 | <p> | |
| 533 | If <code>AbelianGroup(</code><var>ints</var><code>)</code> admits a metacyclic fpf automorphism group | |
| 534 | determined by parameters <var>m</var> and <var>r</var> that is not cyclic | |
| 535 | (see <code>FpfRepresentationsMetacyclic</code> for a presentation), | |
| 536 | then <code>FpfAutomorphismGroupsMetacyclic</code> determines one | |
| 537 | representative for each conjugacy class of such fpf automorphism groups. | |
| 538 | Conjugacy is determined within the whole automorphism group of | |
| 539 | <code>AbelianGroup(</code><var>ints</var><code>)</code>. | |
| 540 | <p> | |
| 541 | <var>ints</var> has to be a list of prime power integers and is sorted in the | |
| 542 | function, according to the order | |
| 543 | <i>p</i><sup><i>i</i></sup> <font face="symbol">£</font> <i>q</i><sup><i>j</i></sup> <font face="symbol">Û</font> <i>p</i> < <i>q</i> or (<i>p</i> = <i>q</i> and <i>i</i> <font face="symbol">³</font> <i>j</i>). | |
| 544 | <p> | |
| 545 | Moreover, the multiplicity of each prime power <i>p</i><sup><i>i</i></sup> in <var>ints</var> has to be | |
| 546 | divisible by <code>DegreeOfIrredFpfRepMetacyclic( p, m, r )</code>, which is | |
| 547 | a multiple of the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 548 | <p> | |
| 549 | A list of pairs of generators (<i>a</i>,<i>b</i> satisfying <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup>, <i>a</i><sup><i>m</i></sup> = 1 | |
| 550 | and <i>b</i><sup><i>n</i></sup> = <i>a</i><sup><i>m</i><font face="symbol">¢</font></sup>) of the nonconjugate fpf automorphism groups is returned | |
| 551 | together with the group <code>AbelianGroup(</code><var>ints</var><code>)</code>, on which the automorphisms act. | |
| 552 | Here <var>ints</var> is sorted with the order above. | |
| 553 | <p> | |
| 554 | For <i>G</i> = (<i>Z</i><sub>3</sub>)<sup>2</sup>×(<i>Z</i><sub>5</sub>)<sup>2</sup> the quaternion | |
| 555 | fpf automorphism group of size 8 (parameters <i>m</i> = 4, <i>r</i> = <font face="symbol">-</font>1) is computed as | |
| 556 | follows: | |
| 557 | <p> | |
| 558 | <pre> | |
| 559 | gap> aux := FpfAutomorphismGroupsMetacyclic( [3,3,5,5], 4, -1 ); | |
| 560 | [ [ [ [ f1, f2, f3, f4 ] -> [ f1^2, f2^3, f3*f4, f3*f4^2 ], | |
| 561 | [ f1, f2, f3, f4 ] -> [ f2^4, f1, f4^2, f3 ] ] ], | |
| 562 | <pc group of size 225 with 4 generators> ] | |
| 563 | gap> fs := aux[1]; | |
| 564 | [ [ [ f1, f2, f3, f4 ] -> [ f1^2, f2^3, f3*f4, f3*f4^2 ], | |
| 565 | [ f1, f2, f3, f4 ] -> [ f2^4, f1, f4^2, f3 ] ] ] | |
| 566 | gap> phi := Group( fs[1] ); | |
| 567 | <group with 2 generators> | |
| 568 | gap> G := aux[2]; | |
| 569 | <pc group of size 225 with 4 generators> | |
| 570 | </pre> | |
| 571 | <p> | |
| 572 | On <i>G</i> = (<i>Z</i><sub>7</sub>)<sup>2</sup>×(<i>Z</i><sub>17</sub>)<sup>2</sup> there are 2 nonconjugate | |
| 573 | fpf automorphism groups isomorphic to the generalized | |
| 574 | quaternion group of size 16 (parameters <i>m</i> = 8, <i>r</i> = <font face="symbol">-</font>1): | |
| 575 | <p> | |
| 576 | <pre> | |
| 577 | gap> aux := FpfAutomorphismGroupsMetacyclic( [7,7,17,17], 8, -1 );; | |
| 578 | gap> fs := aux[1]; | |
| 579 | [ [ [ f1, f2, f3, f4 ] -> [ f1^9, f2^2, f3^4*f4^2, f3*f4^6 ], | |
| 580 | [ f1, f2, f3, f4 ] -> [ f2^16, f1, f3^4*f4^5, f3^5*f4^3 ] ], | |
| 581 | [ [ f1, f2, f3, f4 ] -> [ f1^9, f2^2, f3^3*f4^5, f3^6*f4 ], | |
| 582 | [ f1, f2, f3, f4 ] -> [ f2^16, f1, f3^3*f4^4, f3*f4^4 ] ] ] | |
| 583 | gap> phis := List( fs, Group ); | |
| 584 | [ <group with 2 generators>, <group with 2 generators> ] | |
| 585 | gap> G := aux[2]; | |
| 586 | <pc group of size 14161 with 4 generators> | |
| 587 | </pre> | |
| 588 | <p> | |
| 589 | <a name = "SSEC003.3"></a> | |
| 590 | <li><code>FpfAutomorphismGroups2( </code><var>ints</var><code>, </code><var>m</var><code>, </code><var>r</var><code>, </code><var>k</var><code> )</code> | |
| 591 | <p> | |
| 592 | If <code>AbelianGroup(</code><var>ints</var><code>)</code> admits an fpf automorphism group of type II, | |
| 593 | determined by parameters <var>m</var>, <var>r</var>, <var>k</var> that is not metacyclic | |
| 594 | (see <code>FpfRepresentations2</code> for a presentation), then <code>FpfAutomorphismGroups2</code> | |
| 595 | determines one representative for each conjugacy class of such fpf | |
| 596 | automorphism groups. Conjugacy is determined within the whole automorphism | |
| 597 | group of <code>AbelianGroup(</code><var>ints</var><code>)</code>. | |
| 598 | <p> | |
| 599 | <var>ints</var> has to be a list of prime power integers and is sorted in the | |
| 600 | function, according to the order | |
| 601 | <i>p</i><sup><i>i</i></sup> <font face="symbol">£</font> <i>q</i><sup><i>j</i></sup> <font face="symbol">Û</font> <i>p</i> < <i>q</i> or (<i>p</i> = <i>q</i> and <i>i</i> <font face="symbol">³</font> <i>j</i>). | |
| 602 | <p> | |
| 603 | Note, that the degree of an irreducible fpf representation of a | |
| 604 | type-II-group which is not metacyclic is divisible by 4 and that the | |
| 605 | multiplicity of each prime power <i>p</i><sup><i>i</i></sup> in <var>ints</var> has to be divisible by | |
| 606 | <code>DegreeOfIrredFpfRep2( p, m, r, k )</code>. | |
| 607 | <p> | |
| 608 | A list of triples of generators (<i>a</i>,<i>b</i>,<i>z</i> satisfying <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup>, <i>a</i><sup><i>m</i></sup> = 1 | |
| 609 | and <i>z</i><sup><font face="symbol">-</font>1</sup><i>az</i> = <i>a</i><sup><i>k</i></sup>) of the nonconjugate fpf automorphism groups is | |
| 610 | returned together with the group <code>AbelianGroup(</code><var>ints</var><code>)</code>, on which the | |
| 611 | automorphisms act. | |
| 612 | Here <var>ints</var> is sorted with the order above. | |
| 613 | <p> | |
| 614 | Upto conjugacy there is only one fpf automorphism group of type II with | |
| 615 | parameters <i>m</i> = 30, <i>r</i> = 11, <i>k</i> = <font face="symbol">-</font>1, size 120 on the elementary abelian | |
| 616 | group of size 11<sup>4</sup>: | |
| 617 | <p> | |
| 618 | <pre> | |
| 619 | gap> aux := FpfAutomorphismGroups2( [11,11,11,11], 30, 11, -1 ); | |
| 620 | [ [ [ [ f1, f2, f3, f4 ] -> [ f1^5*f2^4, f1^3*f2^10, f3^2*f4^8, | |
| 621 | f3^6*f4 ], | |
| 622 | [ f1, f2, f3, f4 ] -> [ f1^3*f2^10, f1^10*f2^8, f3^8*f4, | |
| 623 | f3*f4^3 ], | |
| 624 | [ f1, f2, f3, f4 ] -> [ f3^10, f4^10, f1, f2 ] ] ], | |
| 625 | <pc group of size 14641 with 4 generators> ] | |
| 626 | gap> phi := Group( aux[1][1] ); | |
| 627 | <group with 3 generators> | |
| 628 | gap> G := aux[2]; | |
| 629 | <pc group of size 14641 with 4 generators> | |
| 630 | </pre> | |
| 631 | <p> | |
| 632 | <a name = "SSEC003.4"></a> | |
| 633 | <li><code>FpfAutomorphismGroups3( </code><var>ints</var><code>, </code><var>m</var><code>, </code><var>r</var><code> )</code> | |
| 634 | <p> | |
| 635 | If <code>AbelianGroup(</code><var>ints</var><code>)</code> admits an fpf automorphism group of | |
| 636 | type III determined by parameters <var>m</var> and <var>r</var> (see | |
| 637 | <code>FpfRepresentations3</code> for a presentation), then | |
| 638 | <code>FpfAutomorphismGroups3</code> determines one representative for each | |
| 639 | conjugacy class of such fpf automorphism groups. Conjugacy is | |
| 640 | determined within the whole automorphism group of <code>AbelianGroup(</code><var>ints</var><code>)</code>. | |
| 641 | <p> | |
| 642 | <var>ints</var> has to be a list of prime power integers and is sorted in the | |
| 643 | function, according to the order | |
| 644 | <i>p</i><sup><i>i</i></sup> <font face="symbol">£</font> <i>q</i><sup><i>j</i></sup> <font face="symbol">Û</font> <i>p</i> < <i>q</i> or (<i>p</i> = <i>q</i> and <i>i</i> <font face="symbol">³</font> <i>j</i>). | |
| 645 | <p> | |
| 646 | Moreover, the multiplicity of each prime power <i>p</i><sup><i>i</i></sup> in <var>ints</var> has to be | |
| 647 | divisible by <code>DegreeOfIrredFpfRep3( p, m, r )</code>, which is a multiple | |
| 648 | of 2<i>n</i> where <i>n</i> is the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 649 | <p> | |
| 650 | A list of tuples of generators, <var>[p,q,a,b]</var>, (<i>p</i>,<i>q</i> generating the quaternion | |
| 651 | group, <i>a</i>,<i>b</i> satisfying <i>b</i><sup><font face="symbol">-</font>1</sup><i>ab</i> = <i>a</i><sup><i>r</i></sup>, <i>a</i><sup><i>m</i></sup> = 1 and <i>b</i><sup><i>n</i></sup> = <i>a</i><sup><i>m</i><font face="symbol">¢</font></sup>) of the | |
| 652 | nonconjugate fpf automorphism groups is returned together with the group | |
| 653 | <code>AbelianGroup(</code><var>ints</var><code>)</code>, on which the automorphisms act. | |
| 654 | Here <var>ints</var> is sorted with the order above. | |
| 655 | <p> | |
| 656 | For <i>G</i> = (<i>Z</i><sub>5</sub>)<sup>2</sup> the fpf automorphism type-III-group | |
| 657 | isomorphic to SL(2,3) is computed as follows (parameters <i>m</i> = 3, <i>r</i> = 1): | |
| 658 | <p> | |
| 659 | <pre> | |
| 660 | gap> aux := FpfAutomorphismGroups3( [5,5], 3, 1 ); | |
| 661 | [ [ [ [ f1, f2 ] -> [ f1^2, f2^3 ], [ f1, f2 ] -> [ f2^4, f1 ], | |
| 662 | [ f1, f2 ] -> [ f1^3*f2, f1^2*f2 ] ] ], | |
| 663 | <pc group of size 25 with 2 generators> ] | |
| 664 | gap> phi := Group( aux[1][1] ); | |
| 665 | <group with 3 generators> | |
| 666 | gap> G := aux[2]; | |
| 667 | <pc group of size 25 with 2 generators> | |
| 668 | </pre> | |
| 669 | <p> | |
| 670 | <a name = "SSEC003.5"></a> | |
| 671 | <li><code>FpfAutomorphismGroups4( </code><var>ints</var><code>, </code><var>m</var><code>, </code><var>r</var><code>, </code><var>k</var><code> )</code> | |
| 672 | <p> | |
| 673 | If <code>AbelianGroup(</code><var>ints</var><code>)</code> admits an fpf automorphism group of type IV | |
| 674 | determined by parameters <var>m</var>, <var>r</var>, <var>k</var> (see <code>FpfRepresentations4</code> for a | |
| 675 | presentation), then <code>FpfAutomorphismGroups4</code> determines one representative | |
| 676 | for each conjugacy class of such fpf automorphism groups. Conjugacy is | |
| 677 | determined within the whole automorphism group of <code>AbelianGroup(</code><var>ints</var><code>)</code>. | |
| 678 | <p> | |
| 679 | <var>ints</var> has to be a list of prime power integers and is sorted in the | |
| 680 | function, according to the order | |
| 681 | <i>p</i><sup><i>i</i></sup> <font face="symbol">£</font> <i>q</i><sup><i>j</i></sup> <font face="symbol">Û</font> <i>p</i> < <i>q</i> or (<i>p</i> = <i>q</i> and <i>i</i> <font face="symbol">³</font> <i>j</i>). | |
| 682 | <p> | |
| 683 | Moreover, the multiplicity of each prime power <i>p</i><sup><i>i</i></sup> in <var>ints</var> has to be | |
| 684 | divisible by <code>DegreeOfIrredFpfRep4( p, m, r )</code>, which is a multiple | |
| 685 | of 2<i>n</i> where <i>n</i> is the multiplicative order of <i>r</i> modulo <i>m</i>. | |
| 686 | <p> | |
| 687 | A list of tuples of generators, <var>[p,q,a,b,z]</var>, of the nonconjugate fpf | |
| 688 | automorphism groups is returned together with the group | |
| 689 | <code>AbelianGroup(</code><var>ints</var><code>)</code>, on which the automorphisms act. | |
| 690 | Here <var>ints</var> is sorted with the order above. | |
| 691 | If <i>r</i> = 1 mod <i>m</i>, then a list of tuples, <var>[p,q,a,z]</var>, is returned instead. | |
| 692 | <p> | |
| 693 | For <i>G</i> = (<i>Z</i><sub>7</sub>)<sup>2</sup> the fpf automorphism type-IV-group isomorphic the binary | |
| 694 | octahedral group of size 48 (parameters <i>m</i> = 3, <i>r</i> = 1, <i>k</i> = <font face="symbol">-</font>1) | |
| 695 | is computed as follows: | |
| 696 | <p> | |
| 697 | <pre> | |
| 698 | gap> aux := FpfAutomorphismGroups4( [7,7], 3, 1, -1 ); | |
| 699 | [ [ [ [ f1, f2 ] -> [ f1^2*f2^3, f1^3*f2^5 ], | |
| 700 | [ f1, f2 ] -> [ f2^6, f1 ], [ f1, f2 ] -> [ f1^2, f1*f2^4 ], | |
| 701 | [ f1, f2 ] -> [ f1^5*f2^3, f1^3*f2^2 ] ] ], | |
| 702 | <pc group of size 49 with 2 generators> ] | |
| 703 | gap> phi := Group( aux[1][1] ); | |
| 704 | <group with 4 generators> | |
| 705 | gap> G := aux[2]; | |
| 706 | <pc group of size 49 with 2 generators> | |
| 707 | </pre> | |
| 708 | <p> | |
| 709 | <p> | |
| 710 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP008.htm">Previous</a>] [<a href ="CHAP010.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 711 | <P> | |
| 712 | <address>SONATA manual<br>October 2018 | |
| 713 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 10 Nearfields, planar nearrings and weakly divisible nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP009.htm">Previous</a>] [<a href ="CHAP011.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>10 Nearfields, planar nearrings and weakly divisible nearrings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP010.htm#SECT001">Dickson numbers</a> | |
| 8 | <li> <A HREF="CHAP010.htm#SECT002">Dickson nearfields</a> | |
| 9 | <li> <A HREF="CHAP010.htm#SECT003">Exceptional nearfields</a> | |
| 10 | <li> <A HREF="CHAP010.htm#SECT004">Planar nearrings</a> | |
| 11 | <li> <A HREF="CHAP010.htm#SECT005">Weakly divisible nearrings</a> | |
| 12 | </ol><p> | |
| 13 | <p> | |
| 14 | A <strong>nearfield</strong> is a nearring with 1 where each nonzero element has a | |
| 15 | multiplicative inverse. The (additive) group reduct of a finite | |
| 16 | nearfield is necessarily elementary abelian. | |
| 17 | For an exposition of nearfields we refer to <a href="biblio.htm#Waehling:Fastkoerper"><[>Waehling:Fastkoerper</cite></a>]. | |
| 18 | <p> | |
| 19 | Let (<i>N</i>,+,·) be a left nearring. For <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i> we define <i>a</i> <font face="symbol">º</font> <i>b</i> | |
| 20 | iff <i>a</i>·<i>n</i> = <i>b</i>·<i>n</i> for all <i>n</i> <font face="symbol">Î</font> <i>N</i>. If <i>a</i> <font face="symbol">º</font> <i>b</i>, then <i>a</i> and <i>b</i> | |
| 21 | are called <strong>equivalent multipliers</strong>. | |
| 22 | A nearring <i>N</i> is called <strong>planar</strong> if <font face="symbol">|</font> <i>N</i>/<sub> <font face="symbol">º</font> </sub> <font face="symbol">|</font> <font face="symbol">³</font> 3 and if | |
| 23 | for any two non-equivalent multipliers <i>a</i> and <i>b</i> in <i>N</i>, for any <i>c</i> <font face="symbol">Î</font> <i>N</i>, | |
| 24 | the equation <i>a</i>·<i>x</i> = <i>b</i>·<i>x</i> + <i>c</i> has a unique solution. | |
| 25 | See <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>] for basic results on planar nearrings. | |
| 26 | <p> | |
| 27 | All finite nearfields are planar nearrings. | |
| 28 | <p> | |
| 29 | A left nearring (<i>N</i>,+,·) is called <strong>weakly divisible</strong> if | |
| 30 | <font face="symbol">"</font><i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i> <font face="symbol">$</font><i>x</i> <font face="symbol">Î</font> <i>N</i> : <i>a</i>·<i>x</i> = <i>b</i> or <i>b</i>·<i>x</i> = <i>a</i>. | |
| 31 | <p> | |
| 32 | All finite integral planar nearrings are weakly divisible. | |
| 33 | <p> | |
| 34 | <p> | |
| 35 | <h2><a name="SECT001">10.1 Dickson numbers</a></h2> | |
| 36 | <p><p> | |
| 37 | <a name = "SSEC001.1"></a> | |
| 38 | <li><code>IsPairOfDicksonNumbers( </code><var>q</var><code>, </code><var>n</var><code> )</code> | |
| 39 | <p> | |
| 40 | A pair of Dickson numbers (<i>q</i>,<i>n</i>) consists of a prime power integer <i>q</i> | |
| 41 | and a natural number <i>n</i> such that for <i>p</i> = 4 or <i>p</i> prime, <i>p</i><font face="symbol">|</font><i>n</i> implies | |
| 42 | <i>p</i><font face="symbol">|</font><i>q</i><font face="symbol">-</font>1. | |
| 43 | <p> | |
| 44 | <pre> | |
| 45 | gap> IsPairOfDicksonNumbers( 5, 4 ); | |
| 46 | true | |
| 47 | </pre> | |
| 48 | <p> | |
| 49 | <p> | |
| 50 | <h2><a name="SECT002">10.2 Dickson nearfields</a></h2> | |
| 51 | <p><p> | |
| 52 | <a name = "SSEC002.1"></a> | |
| 53 | <li><code>DicksonNearFields( </code><var>q</var><code>, </code><var>n</var><code> )</code> | |
| 54 | <p> | |
| 55 | All finite nearfields with 7 exceptions can be obtained via socalled | |
| 56 | coupling maps from finite fields. These nearfields are called Dickson | |
| 57 | nearfields. | |
| 58 | <p> | |
| 59 | The multiplication map of such a Dickson nearfield is given by a pair of | |
| 60 | Dickson numbers (<i>q</i>,<i>n</i>) in the following way: | |
| 61 | <p> | |
| 62 | Let <i>F</i> = <i>GF</i>(<i>q</i><sup><i>n</i></sup>) and <i>w</i> be a primitive element of <i>F</i>. Let | |
| 63 | <i>H</i> be the subgroup of (<i>F</i>\{0},·) generated by <i>w</i><sup><i>n</i></sup>. | |
| 64 | Then {<i>w</i><sup>(<i>q</i><sup><i>i</i></sup><font face="symbol">-</font>1)/(<i>q</i><font face="symbol">-</font>1)</sup> <font face="symbol">|</font> 0 <font face="symbol">£</font> <i>i</i> <font face="symbol">£</font> <i>n</i><font face="symbol">-</font>1 } is a set of coset | |
| 65 | representatives of <i>H</i> in <i>F</i>\{0}. | |
| 66 | For <i>f</i> <font face="symbol">Î</font> <i>Hw</i><sup>(<i>q</i><sup><i>i</i></sup><font face="symbol">-</font>1)/(<i>q</i><font face="symbol">-</font>1)</sup> and <i>x</i> <font face="symbol">Î</font> <i>F</i> define <i>f</i>*<i>x</i> = <i>f</i>·<i>x</i><sup><i>q</i><sup><i>i</i></sup></sup> | |
| 67 | and 0*<i>x</i> = 0. Then * is a nearfield multiplication on the additive group | |
| 68 | (<i>F</i>,+). | |
| 69 | <p> | |
| 70 | Note that a Dickson nearfield is not uniquely determined by (<i>q</i>,<i>n</i>), since | |
| 71 | <i>w</i> can be chosen arbitrarily. Different choices of <i>w</i> may yield isomorphic | |
| 72 | nearfields. | |
| 73 | <p> | |
| 74 | <code>DicksonNearFields</code> returns a list of the non-isomorphic Dickson nearfields | |
| 75 | determined by the pair of Dickson numbers (<i>q</i>,<i>n</i>) | |
| 76 | <p> | |
| 77 | <pre> | |
| 78 | gap> DicksonNearFields( 5, 4 ); | |
| 79 | [ ExplicitMultiplicationNearRing ( <pc group of size 625 with | |
| 80 | 4 generators> , multiplication ), | |
| 81 | ExplicitMultiplicationNearRing ( <pc group of size 625 with | |
| 82 | 4 generators> , multiplication ) ] | |
| 83 | </pre> | |
| 84 | <p> | |
| 85 | <a name = "SSEC002.2"></a> | |
| 86 | <li><code>NumberOfDicksonNearFields( </code><var>q</var><code>, </code><var>n</var><code> )</code> | |
| 87 | <p> | |
| 88 | <code>NumberOfDicksonNearFields</code> returns the number of non-isomorphic Dickson | |
| 89 | nearfields which can be obtained from a pair of Dickson numbers (<i>q</i>,<i>n</i>). | |
| 90 | This number is given by <font face="symbol">F</font>(<i>n</i>)/<i>k</i>. Here <font face="symbol">F</font>(<i>n</i>) denotes the number | |
| 91 | of relatively prime residues modulo <i>n</i> and <i>k</i> is the multiplicative order | |
| 92 | of <i>p</i> modulo <i>n</i> where <i>p</i> is the prime divisor of <i>q</i>. | |
| 93 | <p> | |
| 94 | <pre> | |
| 95 | gap> NumberOfDicksonNearFields( 5, 4 ); | |
| 96 | 2 | |
| 97 | </pre> | |
| 98 | <p> | |
| 99 | <p> | |
| 100 | <h2><a name="SECT003">10.3 Exceptional nearfields</a></h2> | |
| 101 | <p><p> | |
| 102 | <a name = "SSEC003.1"></a> | |
| 103 | <li><code>ExceptionalNearFields( </code><var>q</var><code> )</code> | |
| 104 | <p> | |
| 105 | There are 7 finite nearfields which cannot be obtained from finite fields | |
| 106 | via a Dickson process. They are of size <i>p</i><sup>2</sup> for | |
| 107 | <i>p</i> = 5, 7, 11, 11, 23, 29, 59. (There exist 2 exceptional nearfields of size | |
| 108 | 121.) | |
| 109 | <p> | |
| 110 | <code>ExceptionalNearFields</code> returns the list of exceptional nearfields for a given | |
| 111 | size <var>q</var>. | |
| 112 | <p> | |
| 113 | <pre> | |
| 114 | gap> ExceptionalNearFields( 25 ); | |
| 115 | [ ExplicitMultiplicationNearRing ( <pc group of size 25 with | |
| 116 | 2 generators> , multiplication ) ] | |
| 117 | </pre> | |
| 118 | <p> | |
| 119 | <a name = "SSEC003.2"></a> | |
| 120 | <li><code>AllExceptionalNearFields()</code> | |
| 121 | <p> | |
| 122 | There are 7 finite nearfields which cannot be obtained from finite fields | |
| 123 | via a Dickson process. They are of size <i>p</i><sup>2</sup> for | |
| 124 | <i>p</i> = 5, 7, 11, 11, 23, 29, 59. (There exist 2 exceptional nearfields of size | |
| 125 | 121.) | |
| 126 | <p> | |
| 127 | <code>AllExceptionalNearFields</code> without argument returns the list of exceptional | |
| 128 | nearfields. | |
| 129 | <p> | |
| 130 | <pre> | |
| 131 | gap> AllExceptionalNearFields(); | |
| 132 | [ ExplicitMultiplicationNearRing ( <pc group of size 25 with | |
| 133 | 2 generators> , multiplication ), | |
| 134 | ExplicitMultiplicationNearRing ( <pc group of size 49 with | |
| 135 | 2 generators> , multiplication ), | |
| 136 | ExplicitMultiplicationNearRing ( <pc group of size 121 with | |
| 137 | 2 generators> , multiplication ), | |
| 138 | ExplicitMultiplicationNearRing ( <pc group of size 121 with | |
| 139 | 2 generators> , multiplication ), | |
| 140 | ExplicitMultiplicationNearRing ( <pc group of size 529 with | |
| 141 | 2 generators> , multiplication ), | |
| 142 | ExplicitMultiplicationNearRing ( <pc group of size 841 with | |
| 143 | 2 generators> , multiplication ), | |
| 144 | ExplicitMultiplicationNearRing ( <pc group of size 3481 with | |
| 145 | 2 generators> , multiplication ) ] | |
| 146 | </pre> | |
| 147 | <p> | |
| 148 | <p> | |
| 149 | <h2><a name="SECT004">10.4 Planar nearrings</a></h2> | |
| 150 | <p><p> | |
| 151 | <a name = "SSEC004.1"></a> | |
| 152 | <li><code>PlanarNearRing( </code><var>G</var><code>, </code><var>phi</var><code>, </code><var>reps</var><code> )</code> | |
| 153 | <p> | |
| 154 | A finite <strong>Ferrero pair</strong> is a pair of groups (<i>N</i>,<font face="symbol">F</font>) where <font face="symbol">F</font> is a | |
| 155 | fixed-point-free automorphism group of (<i>N</i>,+). | |
| 156 | <p> | |
| 157 | Starting with a Ferrero pair (<i>N</i>,<font face="symbol">F</font>) we can construct a planar nearring | |
| 158 | in the following way, <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>:] | |
| 159 | Select representatives, say <i>e</i><sub>1</sub>,<font face="symbol">¼</font>,<i>e</i><sub><i>t</i></sub>, for some or all of the | |
| 160 | non-trivial orbits of <i>N</i> under <font face="symbol">F</font>. | |
| 161 | Let <i>C</i> = <font face="symbol">F</font>(<i>e</i><sub>1</sub>)<font face="symbol">È</font><font face="symbol">¼</font><font face="symbol">È</font><font face="symbol">F</font>(<i>e</i><sub><i>t</i></sub>). | |
| 162 | For each <i>x</i> <font face="symbol">Î</font> <i>N</i> we define <i>a</i> * <i>x</i> = 0 for <i>a</i> <font face="symbol">Î</font> <i>N</i>\<i>C</i>, and | |
| 163 | <i>a</i> * <i>x</i>=<font face="symbol">f</font><sub><i>a</i></sub>(<i>x</i>) for <i>a</i> <font face="symbol">Î</font> <font face="symbol">F</font>(<i>e</i><sub><i>i</i></sub>) <font face="symbol">Ì</font> <i>C</i> and <font face="symbol">f</font><sub><i>a</i></sub>(<i>e</i><sub><i>i</i></sub>)=<i>a</i>. | |
| 164 | Then (<i>N</i>,+,*) is a (left) planar nearring. | |
| 165 | <p> | |
| 166 | Every finite planar nearring can be constructed from some Ferrero pair | |
| 167 | together with a set of orbit representatives in this way. | |
| 168 | <p> | |
| 169 | <code>PlanarNearRing</code> returns the planar nearring on the group <var>G</var> determined by | |
| 170 | the fixed-point-free automorphism group <var>phi</var> and the list of chosen orbit | |
| 171 | representatives <var>reps</var>. | |
| 172 | <p> | |
| 173 | <pre> | |
| 174 | gap> C7 := CyclicGroup( 7 );; | |
| 175 | gap> i := GroupHomomorphismByFunction( C7, C7, x -> x^-1 );; | |
| 176 | gap> phi := Group( i );; | |
| 177 | gap> orbs := Orbits( phi, C7 ); | |
| 178 | [ [ <identity> of ... ], [ f1, f1^6 ], [ f1^2, f1^5 ], | |
| 179 | [ f1^3, f1^4 ] ] | |
| 180 | gap> # choose reps from the orbits | |
| 181 | gap> reps := [orbs[2][1], orbs[3][2]]; | |
| 182 | [ f1, f1^5 ] | |
| 183 | gap> n := PlanarNearRing( C7, phi, reps ); | |
| 184 | ExplicitMultiplicationNearRing ( <pc group of size 7 with | |
| 185 | 1 generators> , multiplication ) | |
| 186 | </pre> | |
| 187 | <p> | |
| 188 | <a name = "SSEC004.2"></a> | |
| 189 | <li><code>OrbitRepresentativesForPlanarNearRing( </code><var>G</var><code>, </code><var>phi</var><code>, </code><var>i</var><code> )</code> | |
| 190 | <p> | |
| 191 | Let (<i>N</i>,<font face="symbol">F</font>) be a Ferrero pair, and let <i>E</i> = { <i>e</i><sub>1</sub>,<font face="symbol">¼</font>,<i>e</i><sub><i>s</i></sub> } and | |
| 192 | <i>F</i> = { <i>f</i><sub>1</sub>,<font face="symbol">¼</font>,<i>f</i><sub><i>t</i></sub> } be two sets of non-zero orbit representatives. | |
| 193 | The nearring obtained from <i>N</i>,<font face="symbol">F</font>, <i>E</i> by the Ferrero construction | |
| 194 | (see <code>PlanarNearRing</code>) is isomorphic to the nearring obtained from <i>N</i>,<font face="symbol">F</font>, <i>F</i> | |
| 195 | iff there exists an automorphism <font face="symbol">a</font> of (<i>N</i>,+) that normalizes <font face="symbol">F</font> | |
| 196 | such that | |
| 197 | { <font face="symbol">a</font>(<i>e</i><sub>1</sub>),<font face="symbol">¼</font>,<font face="symbol">a</font>(<i>e</i><sub><i>s</i></sub>) } = { <i>f</i><sub>1</sub>,<font face="symbol">¼</font>,<i>f</i><sub><i>t</i></sub> }. | |
| 198 | <p> | |
| 199 | The function <code>OrbitRepresentativesForPlanarNearRing</code> | |
| 200 | returns precisely one set of representatives of cardinality <var>i</var> for each | |
| 201 | isomorphism class of planar nearrings which can be generated from the | |
| 202 | Ferrero pair ( <var>G</var>, <var>phi</var> ). | |
| 203 | <p> | |
| 204 | <pre> | |
| 205 | gap> C7 := CyclicGroup( 7 );; | |
| 206 | gap> i := GroupHomomorphismByFunction( C7, C7, x -> x^-1 );; | |
| 207 | gap> phi := Group( i );; | |
| 208 | gap> reps := OrbitRepresentativesForPlanarNearRing( C7, phi, 2 ); | |
| 209 | [ [ f1, f1^2 ], [ f1, f1^5 ] ] | |
| 210 | gap> n1 := PlanarNearRing( C7, phi, reps[1] );; | |
| 211 | gap> n2 := PlanarNearRing( C7, phi, reps[2] );; | |
| 212 | gap> IsIsomorphicNearRing( n1, n2 ); | |
| 213 | false | |
| 214 | </pre> | |
| 215 | <p> | |
| 216 | <p> | |
| 217 | <h2><a name="SECT005">10.5 Weakly divisible nearrings</a></h2> | |
| 218 | <p><p> | |
| 219 | <a name = "SSEC005.1"></a> | |
| 220 | <li><code>WdNearRing( </code><var>G</var><code>, </code><var>psi</var><code>, </code><var>phi</var><code>, </code><var>reps</var><code> )</code> | |
| 221 | <p> | |
| 222 | Every finite (left) weakly divisible nearring (<i>N</i>,+,·) can be constructed | |
| 223 | in the following way: | |
| 224 | <p> | |
| 225 | (1) Let <font face="symbol">y</font> be an endomorphism of the group (<i>N</i>,+) such that Ker | |
| 226 | <font face="symbol">y</font> = Image <font face="symbol">y</font><sup><i>r</i><font face="symbol">-</font>1</sup> for some integer <i>r</i>, <i>r</i> > 0. (Let <font face="symbol">y</font><sup>0</sup> := id.) | |
| 227 | <p> | |
| 228 | (2) Let <font face="symbol">F</font> be an automorphism group of (<i>N</i>,+) such that | |
| 229 | <font face="symbol">y</font><font face="symbol">F</font> <font face="symbol">Í</font> <font face="symbol">F</font><font face="symbol">y</font> and <font face="symbol">F</font> acts fixed-point-free on | |
| 230 | <i>N</i>\ Image <font face="symbol">y</font>. | |
| 231 | (That is, for each | |
| 232 | <font face="symbol">j</font> <font face="symbol">Î</font> <font face="symbol">F</font> there exists <font face="symbol">j</font><font face="symbol">¢</font> <font face="symbol">Î</font> <font face="symbol">F</font> such that | |
| 233 | <font face="symbol">y</font><font face="symbol">j</font> = <font face="symbol">j</font><font face="symbol">¢</font><font face="symbol">y</font> and for all <i>n</i> <font face="symbol">Î</font> <i>N</i>\ Image <font face="symbol">y</font> the | |
| 234 | equality <i>n</i><sup><font face="symbol">j</font></sup> = <i>n</i> implies <font face="symbol">j</font> = id. Note that our functions | |
| 235 | operate from the right just like GAP-mappings do.) | |
| 236 | <p> | |
| 237 | (3) Let <i>E</i> <font face="symbol">Í</font> <i>N</i> be a complete set of orbit representatives for | |
| 238 | <font face="symbol">F</font> on <i>N</i>\ Image <font face="symbol">y</font>, such that for all <i>e</i><sub>1</sub>, <i>e</i><sub>2</sub> <font face="symbol">Î</font> <i>E</i>, for all | |
| 239 | <font face="symbol">j</font> <font face="symbol">Î</font> <font face="symbol">F</font> and for all 1 <font face="symbol">£</font> <i>i</i> <font face="symbol">£</font> <i>r</i><font face="symbol">-</font>1 the equality | |
| 240 | <i>e</i><sub>1</sub><sup><font face="symbol">j</font><font face="symbol">y</font><sup><i>i</i></sup></sup> = <i>e</i><sub>2</sub><sup><font face="symbol">y</font><sup><i>i</i></sup></sup> implies <font face="symbol">j</font><font face="symbol">y</font><sup><i>i</i></sup> = <font face="symbol">y</font><sup><i>i</i></sup>. | |
| 241 | <p> | |
| 242 | Then for all <i>n</i> <font face="symbol">Î</font> <i>N</i>, <i>n</i> <font face="symbol">¹</font> 0, there are <i>i</i> <font face="symbol">³</font> 0 ,<font face="symbol">j</font> <font face="symbol">Î</font> <font face="symbol">F</font> and | |
| 243 | <i>e</i> <font face="symbol">Î</font> <i>E</i> such that <i>n</i> = <i>e</i><sup><font face="symbol">j</font><font face="symbol">y</font><sup><i>i</i></sup></sup>; furthermore, for fixed <i>n</i>, the | |
| 244 | endomorphism <font face="symbol">j</font><font face="symbol">y</font><sup><i>i</i></sup> is independent of the choice of <i>e</i> and | |
| 245 | <font face="symbol">j</font> in the representation of <i>n</i>. | |
| 246 | <p> | |
| 247 | For all <i>x</i> <font face="symbol">Î</font> <i>N</i>, <i>e</i> <font face="symbol">Î</font> <i>E</i>,<font face="symbol">j</font> <font face="symbol">Î</font> <font face="symbol">F</font> and <i>i</i> <font face="symbol">³</font> 0 define 0·<i>x</i> : = 0 | |
| 248 | and | |
| 249 | <br clear="all" /><table border="0" width="100%"><tr><td><table align="center" cellspacing="0" cellpadding="2"><tr><td nowrap="nowrap" align="center"> <i>e</i><sup><font face="symbol">j</font><font face="symbol">y</font><sup><i>i</i></sup></sup>·<i>x</i> : = <i>x</i><sup><font face="symbol">j</font><font face="symbol">y</font><sup><i>i</i></sup></sup> </td></tr></table></td></tr></table> | |
| 250 | Then (<i>N</i>,+,·) is a zerosymmetric (left) wd nearring. | |
| 251 | <p> | |
| 252 | <code>WdNearRing</code> returns the wd nearring on the group <var>G</var> as defined above | |
| 253 | by the nilpotent endomorphism <var>psi</var>, the automorphism group <var>phi</var> and | |
| 254 | a list of orbit representatives <var>reps</var> where the arguments fulfill the | |
| 255 | conditions (1) to (3). | |
| 256 | <p> | |
| 257 | <pre> | |
| 258 | gap> C9 := CyclicGroup( 9 );; | |
| 259 | gap> psi := GroupHomomorphismByFunction( C9, C9, x -> x^3 );; | |
| 260 | gap> Image( psi ); | |
| 261 | Group([ f2, <identity> of ... ]) | |
| 262 | gap> Image( psi ) = Kernel( psi ); | |
| 263 | true | |
| 264 | gap> a := GroupHomomorphismByFunction( C9, C9, x -> x^4 );; | |
| 265 | gap> phi := Group( a );; | |
| 266 | gap> Size( phi ); | |
| 267 | 3 | |
| 268 | gap> orbs := Orbits( phi, C9 ); | |
| 269 | [ [ <identity> of ... ], [ f2 ], [ f2^2 ], [ f1, f1*f2, f1*f2^2 ], | |
| 270 | [ f1^2, f1^2*f2^2, f1^2*f2 ] ] | |
| 271 | gap> # choose reps from the orbits outside of Image( psi ) | |
| 272 | gap> reps := [orbs[4][1], orbs[5][1]]; | |
| 273 | [ f1, f1^2 ] | |
| 274 | gap> n := WdNearRing( C9, psi, phi, reps ); | |
| 275 | ExplicitMultiplicationNearRing ( <pc group of size 9 with | |
| 276 | 2 generators> , multiplication ) | |
| 277 | </pre> | |
| 278 | <p> | |
| 279 | <p> | |
| 280 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP009.htm">Previous</a>] [<a href ="CHAP011.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 281 | <P> | |
| 282 | <address>SONATA manual<br>October 2018 | |
| 283 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA] 11 Designs</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP010.htm">Previous</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>11 Designs</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP011.htm#SECT001">Constructing a design</a> | |
| 8 | <li> <A HREF="CHAP011.htm#SECT002">Properties of a design</a> | |
| 9 | <li> <A HREF="CHAP011.htm#SECT003">Working with the points and blocks of a design</a> | |
| 10 | </ol><p> | |
| 11 | <p> | |
| 12 | Although the functions described in this section were initially meant to | |
| 13 | investigate designs generated from nearrings, they can also be applied to | |
| 14 | other incidence structures. In principal a design is represented as a set | |
| 15 | of points and a set of blocks, a subset of the powerset of the points, with | |
| 16 | containment as incidence relation. | |
| 17 | <p> | |
| 18 | <p> | |
| 19 | <h2><a name="SECT001">11.1 Constructing a design</a></h2> | |
| 20 | <p><p> | |
| 21 | <a name = "SSEC001.1"></a> | |
| 22 | <li><code>DesignFromPointsAndBlocks( </code><var>points</var><code>, </code><var>blocks</var><code> )</code> | |
| 23 | <p> | |
| 24 | <code>DesignFromPointsAndBlocks</code> returns the design with the set of points | |
| 25 | <var>points</var> and the set of blocks <var>blocks</var>, a subset of the powerset of | |
| 26 | <var>points</var>. | |
| 27 | <p> | |
| 28 | <pre> | |
| 29 | gap> points := [1..7];; | |
| 30 | gap> blocks := [[1,2,3],[1,4,5],[1,6,7],[2,4,7],[2,5,6],[3,5,7], | |
| 31 | > [3,4,6]];; | |
| 32 | gap> D := DesignFromPointsAndBlocks( points, blocks ); | |
| 33 | <an incidence structure with 7 points and 7 blocks> | |
| 34 | </pre> | |
| 35 | <p> | |
| 36 | <a name = "SSEC001.2"></a> | |
| 37 | <li><code>DesignFromIncidenceMat( M ) ;</code> | |
| 38 | <p> | |
| 39 | <code>DesignFromIncidenceMat</code> returns the design with incidence matrix <var>M</var>, | |
| 40 | The rows of <var>M</var> are labelled by the set of points 1 to <i>v</i>, the | |
| 41 | columns represent the blocks. | |
| 42 | If the ( <i>i</i>, <i>j</i> ) entry of the matrix <var>M</var> is 1, then the point <i>i</i> is | |
| 43 | incident with the <i>j</i>-th block, i.e. the <i>j</i>-th block consists of those | |
| 44 | points <i>i</i> for which the entry ( <i>i</i>, <i>j</i> ) of <var>M</var> is 1. All other entries | |
| 45 | have to be 0. | |
| 46 | <p> | |
| 47 | <pre> | |
| 48 | gap> M := [[1,0,1,1], | |
| 49 | > [1,1,0,0], | |
| 50 | > [1,1,1,0]];; | |
| 51 | gap> DesignFromIncidenceMat( M ); | |
| 52 | <an incidence structure with 3 points and 4 blocks> | |
| 53 | </pre> | |
| 54 | <p> | |
| 55 | <a name = "SSEC001.3"></a> | |
| 56 | <li><code>DesignFromPlanarNearRing( </code><var>N</var><code>, </code><var>type</var><code> )</code> | |
| 57 | <p> | |
| 58 | <code>DesignFromPlanarNearRing</code> returns a design obtained from the planar | |
| 59 | nearring <var>N</var> following the constructions of James R. Clay | |
| 60 | <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>]. | |
| 61 | <p> | |
| 62 | If <var>type</var> = <code>"*"</code>, <code>DesignFromPlanarNearRing</code> returns the design | |
| 63 | (<i>N</i> ,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) in the notation of J. R. Clay with the elements of <var>N</var> as | |
| 64 | set of points and {<i>N</i><sup>*</sup>·<i>a</i>+<i>b</i> <font face="symbol">|</font> <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i>, <i>a</i> <font face="symbol">¹</font> 0 } as set of blocks. | |
| 65 | Here <i>N</i><sup>*</sup> is the set of elements <i>x</i> <font face="symbol">Î</font> <i>N</i> satisfying <i>x</i>·<i>N</i> = <i>N</i>. | |
| 66 | <p> | |
| 67 | If <var>type</var> = <code>" "</code> (blank), <code>DesignFromPlanarNearRing</code> returns the design | |
| 68 | (<i>N</i> ,<i>B</i>, <font face="symbol">Î</font> ) in the notation of J. R. Clay with the elements of <var>N</var> as | |
| 69 | set of points and {<i>N</i>·<i>a</i>+<i>b</i> <font face="symbol">|</font> <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i>, <i>a</i> <font face="symbol">¹</font> 0 } as set of | |
| 70 | blocks. | |
| 71 | <p> | |
| 72 | <pre> | |
| 73 | gap> n := LibraryNearRing( GTW9_2, 90 ); | |
| 74 | LibraryNearRing(9/2, 90) | |
| 75 | gap> IsPlanarNearRing( n ); | |
| 76 | true | |
| 77 | gap> D1 := DesignFromPlanarNearRing( n, "*" ); | |
| 78 | <a 2 - ( 9, 4, 3 ) nearring generated design> | |
| 79 | gap> D2 := DesignFromPlanarNearRing( n, " " ); | |
| 80 | <a 2 - ( 9, 5, 5 ) nearring generated design> | |
| 81 | </pre> | |
| 82 | <p> | |
| 83 | <a name = "SSEC001.4"></a> | |
| 84 | <li><code>DesignFromFerreroPair( </code><var>G</var><code>, </code><var>phi</var><code>, </code><var>type</var><code> )</code> | |
| 85 | <p> | |
| 86 | <code>DesignFromFerreroPair</code> returns a design obtained from the group <var>G</var>, and | |
| 87 | a group of fixed-point-free automorphisms <var>phi</var> acting on <var>G</var> following the | |
| 88 | constructions of James R. Clay <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>]. | |
| 89 | <p> | |
| 90 | If <var>type</var> = <code>"*"</code>, <code>DesignFromFerreroPair</code> returns the design | |
| 91 | (<i>G</i> ,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) in the notation of J. R. Clay with the elements of <var>G</var> as | |
| 92 | set of points and the nonzero orbits of <var>G</var> under <var>phi</var> and their | |
| 93 | translates by group-elements as set of blocks. | |
| 94 | <p> | |
| 95 | If <var>type</var> = <code>" "</code> (blank), <code>DesignFromFerreroPair</code> returns the design | |
| 96 | (<i>G</i> ,<i>B</i>, <font face="symbol">Î</font> ) in the notation of J. R. Clay with the elements of <var>G</var> as | |
| 97 | set of points and the nonzero orbits of <var>G</var> under <var>phi</var> joined with the zero | |
| 98 | of <var>G</var> and their translates by group-elements as set of blocks. | |
| 99 | <p> | |
| 100 | <pre> | |
| 101 | gap> aux := FpfAutomorphismGroupsCyclic( [3,3], 4 ); | |
| 102 | [ [ [ f1, f2 ] -> [ f1*f2, f1*f2^2 ] ], | |
| 103 | <pc group of size 9 with 2 generators> ] | |
| 104 | gap> f := aux[1][1]; | |
| 105 | [ f1, f2 ] -> [ f1*f2, f1*f2^2 ] | |
| 106 | gap> phi := Group( f ); | |
| 107 | <group with 1 generators> | |
| 108 | gap> G := aux[2]; | |
| 109 | <pc group of size 9 with 2 generators> | |
| 110 | gap> D3 := DesignFromFerreroPair( G, phi, "*" ); | |
| 111 | <a 2 - ( 9, 4, 3 ) nearring generated design> | |
| 112 | gap> # D3 is actually isomorphic to D1 | |
| 113 | </pre> | |
| 114 | <p> | |
| 115 | <a name = "SSEC001.5"></a> | |
| 116 | <li><code>DesignFromWdNearRing( </code><var>N</var><code> )</code> | |
| 117 | <p> | |
| 118 | <code>DesignFromWdNearring</code> returns a design obtained from the weakly divisible | |
| 119 | nearring <var>N</var> with cyclic additive group of prime power order. Following the | |
| 120 | constructions of A. Benini, F. Morini and S. Pellegrini, we take the elements | |
| 121 | of <var>N</var> as set of points and {<i>N</i>·<i>a</i>+<i>b</i> <font face="symbol">|</font> <i>a</i> <font face="symbol">Î</font> <i>C</i>, <i>b</i> <font face="symbol">Î</font> <i>N</i> } as set of | |
| 122 | blocks. Here <i>C</i> is the set of elements <i>a</i> <font face="symbol">Î</font> <i>N</i> such that <i>a</i>·<i>N</i> = <i>N</i>. | |
| 123 | <p> | |
| 124 | <pre> | |
| 125 | gap> n := LibraryNearRing( GTW9_1, 202 ); | |
| 126 | LibraryNearRing(9/1, 202) | |
| 127 | gap> IsWdNearRing( n ); | |
| 128 | true | |
| 129 | gap> DesignFromWdNearRing( n ); | |
| 130 | <a 1 - ( 9, 5, 10 ) nearring generated design> | |
| 131 | </pre> | |
| 132 | <p> | |
| 133 | <p> | |
| 134 | <h2><a name="SECT002">11.2 Properties of a design</a></h2> | |
| 135 | <p><p> | |
| 136 | <a name = "SSEC002.1"></a> | |
| 137 | <li><code>PointsOfDesign( </code><var>D</var><code> )</code> | |
| 138 | <p> | |
| 139 | <code>PointsOfDesign</code> returns the actual list of points of the design <var>D</var>, not | |
| 140 | their positions, no matter how the points of the design <var>D</var> may be | |
| 141 | represented. To get the representation of those points, whose positions in | |
| 142 | the list of all points are given by the list <var>pointnrs</var>, one can use | |
| 143 | <code>PointsOfDesign( </code><var>D</var><code> ){</code><var>pointnrs</var><code>}</code>. | |
| 144 | <p> | |
| 145 | <pre> | |
| 146 | gap> D1; | |
| 147 | <a 2 - ( 9, 4, 3 ) nearring generated design> | |
| 148 | gap> PointsOfDesign( D1 ); | |
| 149 | [ (()), ((4,5,6)), ((4,6,5)), ((1,2,3)), ((1,2,3)(4,5,6)), | |
| 150 | ((1,2,3)(4,6,5)), ((1,3,2)), ((1,3,2)(4,5,6)), ((1,3,2)(4,6,5)) ] | |
| 151 | gap> PointsOfDesign( D1 ){[2,4]}; | |
| 152 | [ ((4,5,6)), ((1,2,3)) ] | |
| 153 | gap> # returns the points in position 2 and 4 | |
| 154 | </pre> | |
| 155 | <p> | |
| 156 | <a name = "SSEC002.2"></a> | |
| 157 | <li><code>BlocksOfDesign( </code><var>D</var><code> )</code> | |
| 158 | <p> | |
| 159 | <code>BlocksOfDesign</code> returns the actual list of blocks of the design <var>D</var>, not | |
| 160 | their positions. Blocks are represented as lists of points. A point is | |
| 161 | incident with a block if the point is an element of the | |
| 162 | block. To get the representation of those blocks, whose positions in | |
| 163 | the list of all blocks are given by the list <var>blocknrs</var>, one can use | |
| 164 | <code>BlocksOfDesign( </code><var>D</var><code> ){</code><var>blocknrs</var><code>}</code>. | |
| 165 | <p> | |
| 166 | <pre> | |
| 167 | gap> Length( BlocksOfDesign( D1 ) ); | |
| 168 | 18 | |
| 169 | gap> BlocksOfDesign( D1 ){[3]}; | |
| 170 | [ [ ((4,6,5)), (()), ((1,2,3)(4,5,6)), ((1,3,2)(4,5,6)) ] ] | |
| 171 | gap> # returns the block in position 3 as a list of points | |
| 172 | </pre> | |
| 173 | <p> | |
| 174 | <a name = "SSEC002.3"></a> | |
| 175 | <li><code>DesignParameter( </code><var>D</var><code> )</code> | |
| 176 | <p> | |
| 177 | <code>DesignParameter</code> returns the set of paramaters <i>t</i>, <i>v</i>, <i>b</i>, <i>r</i>, <i>k</i>, <font face="symbol">l</font> | |
| 178 | of the design <var>D</var>. Here <i>v</i> is the size of the set of points | |
| 179 | <code>PointsOfDesign</code>, <i>b</i> is the size of the set of blocks <code>PointsOfDesign</code>, | |
| 180 | every point is incident with precisely <i>r</i> blocks, every block is incident | |
| 181 | with precisely <i>k</i> points, every <i>t</i> distinct points are together incident | |
| 182 | with precisely <font face="symbol">l</font> blocks. | |
| 183 | <p> | |
| 184 | <pre> | |
| 185 | gap> DesignParameter( D1 ); | |
| 186 | [ 2, 9, 18, 8, 4, 3 ] | |
| 187 | gap> # t = 2, v = 9, b = 18, r = 8, k = 4, lambda = 3 | |
| 188 | </pre> | |
| 189 | <p> | |
| 190 | <a name = "SSEC002.4"></a> | |
| 191 | <li><code>IncidenceMat( </code><var>D</var><code> )</code> | |
| 192 | <p> | |
| 193 | <code>IncidenceMat</code> returns the incidence matrix of the design <var>D</var>, where the | |
| 194 | rows are labelled by the positions of the points in <code>PointsOfDesign</code>, the | |
| 195 | columns are labelled by the positions of the blocks in <code>BlocksOfDesign</code>. | |
| 196 | If the point in position <i>i</i> is incident with the block in position <i>j</i>, then | |
| 197 | the ( <i>i</i>, <i>j</i> ) entry of the matrix <code>IncidenceMat</code> is 1, else it is 0. | |
| 198 | <p> | |
| 199 | <pre> | |
| 200 | gap> M1 := IncidenceMat( D1 ); | |
| 201 | [ [ 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1 ], | |
| 202 | [ 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1 ], | |
| 203 | [ 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 ], | |
| 204 | [ 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 ], | |
| 205 | [ 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1 ], | |
| 206 | [ 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0 ], | |
| 207 | [ 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0 ], | |
| 208 | [ 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0 ], | |
| 209 | [ 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0 ] ] | |
| 210 | </pre> | |
| 211 | <p> | |
| 212 | <a name = "SSEC002.5"></a> | |
| 213 | <li><code>PrintIncidenceMat( </code><var>D</var><code> )</code> | |
| 214 | <p> | |
| 215 | <code>PrintIncidenceMat</code> prints only the entries of the incidence matrix | |
| 216 | <code>IncidenceMat</code> of the design without commas. If the point in position <i>i</i> is | |
| 217 | incident with the block in position <i>j</i>, then there is 1 in the <i>i</i>-th | |
| 218 | row, <i>j</i>-th column, else there is '.', a dot. | |
| 219 | <p> | |
| 220 | <pre> | |
| 221 | gap> PrintIncidenceMat( D1 ); | |
| 222 | ..1.1.1..1.11..1.1 | |
| 223 | 1...1..11..1.11..1 | |
| 224 | 1.1....1.11..1.11. | |
| 225 | 1..1.1..1.1.1..1.1 | |
| 226 | .11..11...1..11..1 | |
| 227 | .1.11.1.1....1.11. | |
| 228 | 1..1.11..1.1..1.1. | |
| 229 | .11..1.11..11...1. | |
| 230 | .1.11..1.11.1.1... | |
| 231 | </pre> | |
| 232 | <p> | |
| 233 | <a name = "SSEC002.6"></a> | |
| 234 | <li><code>BlockIntersectionNumbers( </code><var>D</var><code> )</code> | |
| 235 | <a name = "SSEC002.6"></a> | |
| 236 | <li><code>BlockIntersectionNumbersK( </code><var>D</var><code>, </code><var>blocknr</var><code> )</code> | |
| 237 | <p> | |
| 238 | In the first form <code>BlockIntersectionNumbers</code> returns the list of | |
| 239 | cardinalities of the intersection of each block with all other blocks of the | |
| 240 | design <var>D</var>. | |
| 241 | In the second form <code>BlockIntersectionNumbers</code> returns the list of | |
| 242 | cardinalities of the intersection of the block in position <var>blocknr</var> with | |
| 243 | all other blocks of the design <var>D</var>. | |
| 244 | <p> | |
| 245 | <pre> | |
| 246 | gap> BlockIntersectionNumbers( D1, 2 ); | |
| 247 | [ 0, 4, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1 ] | |
| 248 | gap> # the second has empty intersection with the first block | |
| 249 | gap> # and intersects all others in at most 2 points | |
| 250 | </pre> | |
| 251 | <p> | |
| 252 | <a name = "SSEC002.7"></a> | |
| 253 | <li><code>IsCircularDesign( </code><var>D</var><code> )</code> | |
| 254 | <p> | |
| 255 | <code>IsCircularDesign</code> returns <code>true</code> if the design <var>D</var> is circular and <code>false</code> | |
| 256 | otherwise. The design <var>D</var> has to be the result of <code>DesignFromPlanarNearRing</code> | |
| 257 | or <code>DesignFromFerreroPair</code>, since <code>IsCircularDesign</code> assumes the particular | |
| 258 | structure of such a nearring-generated design. | |
| 259 | <p> | |
| 260 | A design <var>D</var> is <strong>circular</strong> if every two distinct blocks intersect in at most | |
| 261 | two points. | |
| 262 | <p> | |
| 263 | <code>IsCircularDesign</code> calls the function <code>BlockIntersectionNumbers</code>. | |
| 264 | <p> | |
| 265 | <pre> | |
| 266 | gap> IsCircularDesign( D1 ); | |
| 267 | true | |
| 268 | </pre> | |
| 269 | <p> | |
| 270 | <p> | |
| 271 | <h2><a name="SECT003">11.3 Working with the points and blocks of a design</a></h2> | |
| 272 | <p><p> | |
| 273 | <a name = "SSEC003.1"></a> | |
| 274 | <li><code>IsPointIncidentBlock( </code><var>D</var><code>, </code><var>pointnr</var><code>, </code><var>blocknr</var><code> )</code> | |
| 275 | <p> | |
| 276 | <code>IsPointIncidentBlock</code> returns <code>true</code> if the point whose position in the list | |
| 277 | <code>PointsOfDesign( </code><var>D</var><code> )</code> is given by <var>pointnr</var> is incident with the block | |
| 278 | whose position in the list <code>BlocksOfDesign( </code><var>D</var><code> )</code> is given by <var>blocknr</var>, | |
| 279 | that is, the point is contained in the block as an element in a set. | |
| 280 | <p> | |
| 281 | <pre> | |
| 282 | gap> IsPointIncidentBlock( D1, 3, 1 ); | |
| 283 | true | |
| 284 | gap> # point 3 is incident with block 1 | |
| 285 | gap> IsPointIncidentBlock( D1, 3, 2 ); | |
| 286 | false | |
| 287 | </pre> | |
| 288 | <p> | |
| 289 | <a name = "SSEC003.2"></a> | |
| 290 | <li><code>PointsIncidentBlocks( </code><var>D</var><code>, </code><var>blocknrs</var><code> )</code> | |
| 291 | <p> | |
| 292 | <code>PointsIncidentBlocks</code> returns a list of positions of those points of the | |
| 293 | design <var>D</var> which are incident with the blocks, whose positions are given in | |
| 294 | the list <var>blocknrs</var>. | |
| 295 | <p> | |
| 296 | <pre> | |
| 297 | gap> PointsIncidentBlocks( D1, [1, 4] ); | |
| 298 | [ 4, 7 ] | |
| 299 | gap> # block 1 and block 4 are together incident with | |
| 300 | gap> # points 4 and 7 | |
| 301 | </pre> | |
| 302 | <p> | |
| 303 | <a name = "SSEC003.3"></a> | |
| 304 | <li><code>BlocksIncidentPoints( </code><var>D</var><code>, </code><var>pointnrs</var><code> )</code> | |
| 305 | <p> | |
| 306 | <code>BlocksIncidentPoints</code> returns a list of positions of the blocks of the | |
| 307 | design <var>D</var> which are incident with those points, whose positions are given | |
| 308 | in the list <var>pointnrs</var>. | |
| 309 | <p> | |
| 310 | <pre> | |
| 311 | gap> BlocksIncidentPoints( D1, [2, 7] ); | |
| 312 | [ 1, 12, 15 ] | |
| 313 | gap> # point 2 and point 7 are together incident with | |
| 314 | gap> # blocks 1, 12, 15 | |
| 315 | gap> BlocksOfDesign( D1 ){last}; | |
| 316 | [ [ ((4,5,6)), ((4,6,5)), ((1,2,3)), ((1,3,2)) ], | |
| 317 | [ ((1,3,2)), ((1,3,2)(4,5,6)), (()), ((4,5,6)) ], | |
| 318 | [ ((1,3,2)(4,6,5)), ((1,3,2)), ((4,5,6)), ((1,2,3)(4,5,6)) ] ] | |
| 319 | gap> # the actual point sets of blocks 1, 12, and 15 | |
| 320 | gap> BlocksIncidentPoints( D1, [2, 3, 7] ); | |
| 321 | [ 1 ] | |
| 322 | gap> # points 2, 3, 7 are together incident with block 1 | |
| 323 | gap> PointsIncidentBlocks( D1, [1] ); | |
| 324 | [ 2, 3, 4, 7 ] | |
| 325 | gap> # block 1 is incident with points 2, 3, 4, 7 | |
| 326 | </pre> | |
| 327 | <p> | |
| 328 | <p> | |
| 329 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP010.htm">Previous</a>] [<a href = "theindex.htm">Index</a>] | |
| 330 | <P> | |
| 331 | <address>SONATA manual<br>October 2018 | |
| 332 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - References</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - References</h1><dl> | |
| 3 | </dl><p> | |
| 4 | [<a href="chapters.htm">Up</a>]<p> | |
| 5 | <P> | |
| 6 | <address>SONATA manual<br>October 2018 | |
| 7 | </address></body></html> |
| 0 | <html><head><title>SONATA : a GAP 4 package - Chapters</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Chapters</h1> | |
| 3 | <ul> | |
| 4 | <li><a href="theindex.htm">Index</a> | |
| 5 | </ul> | |
| 6 | <ol> | |
| 7 | <li><a href="CHAP001.htm">Supportive functions for groups</a> | |
| 8 | <li><a href="CHAP002.htm">Nearrings</a> | |
| 9 | <li><a href="CHAP003.htm">The nearring library</a> | |
| 10 | <li><a href="CHAP004.htm">Arbitrary functions on groups: EndoMappings</a> | |
| 11 | <li><a href="CHAP005.htm">Transformation nearrings</a> | |
| 12 | <li><a href="CHAP006.htm">Nearring ideals</a> | |
| 13 | <li><a href="CHAP007.htm">Graphic ideal lattices (X-GAP only)</a> | |
| 14 | <li><a href="CHAP008.htm">N-groups</a> | |
| 15 | <li><a href="CHAP009.htm">Fixed-point-free automorphism groups</a> | |
| 16 | <li><a href="CHAP010.htm">Nearfields, planar nearrings and weakly divisible nearrings</a> | |
| 17 | <li><a href="CHAP011.htm">Designs</a> | |
| 18 | </ol> | |
| 19 | <ul> | |
| 20 | <li><a href="biblio.htm">References</a> | |
| 21 | <li><a href="theindex.htm">Index</a> | |
| 22 | </ul><p> | |
| 23 | <P> | |
| 24 | <address>SONATA manual<br>October 2018 | |
| 25 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index A</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index A</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Accessing nearring elements <a href="CHAP002.htm#SECT006">2.6</a> | |
| 26 | <dt>Accessing the information about a nearring stored in the library <a href="CHAP003.htm#SECT004">3.4</a> | |
| 27 | <dt>ActionOfNearRingOnNGroup <a href="CHAP008.htm#SSEC003.3">8.3.3</a> | |
| 28 | <dt>AllExceptionalNearFields <a href="CHAP010.htm#SSEC003.2">10.3.2</a> | |
| 29 | <dt>AllLibraryNearRings <a href="CHAP003.htm#SSEC001.3">3.1.3</a> | |
| 30 | <dt>AllLibraryNearRingsWithOne <a href="CHAP003.htm#SSEC001.6">3.1.6</a> | |
| 31 | <dt>Arbitrary functions on groups: EndoMappings <a href="CHAP004.htm">4.0</a> | |
| 32 | <dt>AsEndoMapping <a href="CHAP004.htm#SSEC001.3">4.1.3</a> | |
| 33 | <dt>AsExplicitMultiplicationNearRing <a href="CHAP005.htm#SSEC004.2">5.4.2</a> | |
| 34 | <dt>AsGroupGeneralMappingByImages <a href="CHAP004.htm#SSEC001.4">4.1.4</a> | |
| 35 | <dt>AsGroupReductElement <a href="CHAP002.htm#SSEC006.2">2.6.2</a> | |
| 36 | <dt>AsList, near ring ideals <a href="CHAP006.htm#SSEC005.1">6.5.1</a> | |
| 37 | <dt>AsList, near rings <a href="CHAP002.htm#SSEC007.1">2.7.1</a> | |
| 38 | <dt>AsNearRingElement <a href="CHAP002.htm#SSEC006.1">2.6.1</a> | |
| 39 | <dt>AsPermGroup <a href="CHAP001.htm#SSEC012.1">1.12.1</a> | |
| 40 | <dt>AsSortedList, near ring ideals <a href="CHAP006.htm#SSEC005.2">6.5.2</a> | |
| 41 | <dt>AsSortedList, near rings <a href="CHAP002.htm#SSEC007.2">2.7.2</a> | |
| 42 | <dt>AsTransformationNearRing <a href="CHAP005.htm#SSEC004.1">5.4.1</a> | |
| 43 | <dt>AutomorphismNearRing <a href="CHAP005.htm#SSEC002.6">5.2.6</a> | |
| 44 | <dt>Automorphisms <a href="CHAP001.htm#SSEC004.1">1.4.1</a> | |
| 45 | <dt>Automorphisms, near rings <a href="CHAP002.htm#SSEC013.1">2.13.1</a> | |
| 46 | </dl><p> | |
| 47 | [<a href="chapters.htm">Up</a>]<p> | |
| 48 | <P> | |
| 49 | <address>SONATA manual<br>October 2018 | |
| 50 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index B</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index B</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>BlockIntersectionNumbers <a href="CHAP011.htm#SSEC002.6">11.2.6</a> | |
| 26 | <dt>BlockIntersectionNumbersK <a href="CHAP011.htm#SSEC002.6">11.2.6</a> | |
| 27 | <dt>BlocksIncidentPoints <a href="CHAP011.htm#SSEC003.3">11.3.3</a> | |
| 28 | <dt>BlocksOfDesign <a href="CHAP011.htm#SSEC002.2">11.2.2</a> | |
| 29 | </dl><p> | |
| 30 | [<a href="chapters.htm">Up</a>]<p> | |
| 31 | <P> | |
| 32 | <address>SONATA manual<br>October 2018 | |
| 33 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index C</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index C</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>CentralizerNearRing <a href="CHAP005.htm#SSEC002.12">5.2.12</a> | |
| 26 | <dt>ClosureNearRingIdeal <a href="CHAP006.htm#SSEC011.5">6.11.5</a> | |
| 27 | <dt>ClosureNearRingLeftIdeal <a href="CHAP006.htm#SSEC011.3">6.11.3</a> | |
| 28 | <dt>ClosureNearRingRightIdeal <a href="CHAP006.htm#SSEC011.4">6.11.4</a> | |
| 29 | <dt>Commutators <a href="CHAP006.htm#SECT012">6.12</a> | |
| 30 | <dt>Comparision of ideals <a href="CHAP006.htm#SECT010">6.10</a> | |
| 31 | <dt>CompatibleFunctionNearRing <a href="CHAP005.htm#SSEC002.8">5.2.8</a> | |
| 32 | <dt>CongruenceNoetherianQuotient, for nearrings of polynomial functions <a href="CHAP005.htm#SSEC005.2">5.5.2</a> | |
| 33 | <dt>CongruenceNoetherianQuotientForInnerAutomorphismNearRings , for inner automorphism nearrings <a href="CHAP005.htm#SSEC005.3">5.5.3</a> | |
| 34 | <dt>ConstantEndoMapping <a href="CHAP004.htm#SSEC001.7">4.1.7</a> | |
| 35 | <dt>Constructing a design <a href="CHAP011.htm#SECT001">11.1</a> | |
| 36 | <dt>Constructing subnearrings <a href="CHAP002.htm#SECT017">2.17</a> | |
| 37 | <dt>Constructing transformation nearrings <a href="CHAP005.htm#SECT001">5.1</a> | |
| 38 | <dt>Construction of N-groups <a href="CHAP008.htm#SECT001">8.1</a> | |
| 39 | <dt>Construction of nearring ideals <a href="CHAP006.htm#SECT001">6.1</a> | |
| 40 | <dt>Construction of nearrings <a href="CHAP002.htm#SECT002">2.2</a> | |
| 41 | <dt>Coset representatives <a href="CHAP001.htm#SECT010">1.10</a> | |
| 42 | </dl><p> | |
| 43 | [<a href="chapters.htm">Up</a>]<p> | |
| 44 | <P> | |
| 45 | <address>SONATA manual<br>October 2018 | |
| 46 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index D</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index D</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Defining a nearring multiplication <a href="CHAP002.htm#SECT001">2.1</a> | |
| 26 | <dt>Defining endo mappings <a href="CHAP004.htm#SECT001">4.1</a> | |
| 27 | <dt>DegreeOfIrredFpfRep2 <a href="CHAP009.htm#SSEC002.4">9.2.4</a> | |
| 28 | <dt>DegreeOfIrredFpfRep3 <a href="CHAP009.htm#SSEC002.5">9.2.5</a> | |
| 29 | <dt>DegreeOfIrredFpfRep4 <a href="CHAP009.htm#SSEC002.6">9.2.6</a> | |
| 30 | <dt>DegreeOfIrredFpfRepCyclic <a href="CHAP009.htm#SSEC002.2">9.2.2</a> | |
| 31 | <dt>DegreeOfIrredFpfRepMetacyclic <a href="CHAP009.htm#SSEC002.3">9.2.3</a> | |
| 32 | <dt>DesignFromFerreroPair <a href="CHAP011.htm#SSEC001.4">11.1.4</a> | |
| 33 | <dt>DesignFromIncidenceMat <a href="CHAP011.htm#SSEC001.2">11.1.2</a> | |
| 34 | <dt>DesignFromPlanarNearRing <a href="CHAP011.htm#SSEC001.3">11.1.3</a> | |
| 35 | <dt>DesignFromPointsAndBlocks <a href="CHAP011.htm#SSEC001.1">11.1.1</a> | |
| 36 | <dt>DesignFromWdNearRing <a href="CHAP011.htm#SSEC001.5">11.1.5</a> | |
| 37 | <dt>DesignParameter <a href="CHAP011.htm#SSEC002.3">11.2.3</a> | |
| 38 | <dt>Designs <a href="CHAP011.htm">11.0</a> | |
| 39 | <dt>Dickson nearfields <a href="CHAP010.htm#SECT002">10.2</a> | |
| 40 | <dt>Dickson numbers <a href="CHAP010.htm#SECT001">10.1</a> | |
| 41 | <dt>DicksonNearFields <a href="CHAP010.htm#SSEC002.1">10.2.1</a> | |
| 42 | <dt>Direct products of nearrings <a href="CHAP002.htm#SECT003">2.3</a> | |
| 43 | <dt>DirectProductNearRing <a href="CHAP002.htm#SSEC003.1">2.3.1</a> | |
| 44 | <dt>DistributiveElements <a href="CHAP002.htm#SSEC021.2">2.21.2</a> | |
| 45 | <dt>Distributivity in a nearring <a href="CHAP002.htm#SECT021">2.21</a> | |
| 46 | <dt>Distributors <a href="CHAP002.htm#SSEC021.1">2.21.1</a> | |
| 47 | </dl><p> | |
| 48 | [<a href="chapters.htm">Up</a>]<p> | |
| 49 | <P> | |
| 50 | <address>SONATA manual<br>October 2018 | |
| 51 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index E</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index E</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Elements of a nearring with special properties <a href="CHAP002.htm#SECT022">2.22</a> | |
| 26 | <dt>EndoMappingByFunction <a href="CHAP004.htm#SSEC001.2">4.1.2</a> | |
| 27 | <dt>EndoMappingByPositionList <a href="CHAP004.htm#SSEC001.1">4.1.1</a> | |
| 28 | <dt>EndomorphismNearRing <a href="CHAP005.htm#SSEC002.5">5.2.5</a> | |
| 29 | <dt>Endomorphisms <a href="CHAP001.htm#SSEC003.1">1.3.1</a> | |
| 30 | <dt>Endomorphisms, near rings <a href="CHAP002.htm#SSEC012.1">2.12.1</a> | |
| 31 | <dt>Enumerator, near ring ideals <a href="CHAP006.htm#SSEC005.3">6.5.3</a> | |
| 32 | <dt>Enumerator, near rings <a href="CHAP002.htm#SSEC007.3">2.7.3</a> | |
| 33 | <dt>Exceptional nearfields <a href="CHAP010.htm#SECT003">10.3</a> | |
| 34 | <dt>ExceptionalNearFields <a href="CHAP010.htm#SSEC003.1">10.3.1</a> | |
| 35 | <dt>ExplicitMultiplicationNearRing <a href="CHAP002.htm#SSEC002.1">2.2.1</a> | |
| 36 | <dt>ExplicitMultiplicationNearRingNC <a href="CHAP002.htm#SSEC002.2">2.2.2</a> | |
| 37 | <dt>Extracting nearrings from the library <a href="CHAP003.htm#SECT001">3.1</a> | |
| 38 | </dl><p> | |
| 39 | [<a href="chapters.htm">Up</a>]<p> | |
| 40 | <P> | |
| 41 | <address>SONATA manual<br>October 2018 | |
| 42 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index F</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index F</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Factor nearrings <a href="CHAP006.htm#SECT014">6.14</a> | |
| 26 | <dt>FactorNearRing <a href="CHAP006.htm#SSEC014.1">6.14.1</a> | |
| 27 | <dt>Fixed-point-free automorphism groups <a href="CHAP009.htm">9.0</a> <a href="CHAP009.htm#SECT003">9.3</a> | |
| 28 | <dt>Fixed-point-free automorphism groups and Frobenius groups <a href="CHAP009.htm#SECT001">9.1</a> | |
| 29 | <dt>Fixed-point-free representations <a href="CHAP009.htm#SECT002">9.2</a> | |
| 30 | <dt>FpfAutomorphismGroups2 <a href="CHAP009.htm#SSEC003.3">9.3.3</a> | |
| 31 | <dt>FpfAutomorphismGroups3 <a href="CHAP009.htm#SSEC003.4">9.3.4</a> | |
| 32 | <dt>FpfAutomorphismGroups4 <a href="CHAP009.htm#SSEC003.5">9.3.5</a> | |
| 33 | <dt>FpfAutomorphismGroupsCyclic <a href="CHAP009.htm#SSEC003.1">9.3.1</a> | |
| 34 | <dt>FpfAutomorphismGroupsMaxSize <a href="CHAP009.htm#SSEC001.2">9.1.2</a> | |
| 35 | <dt>FpfAutomorphismGroupsMetacyclic <a href="CHAP009.htm#SSEC003.2">9.3.2</a> | |
| 36 | <dt>FpfRepresentations2 <a href="CHAP009.htm#SSEC002.9">9.2.9</a> | |
| 37 | <dt>FpfRepresentations3 <a href="CHAP009.htm#SSEC002.10">9.2.10</a> | |
| 38 | <dt>FpfRepresentations4 <a href="CHAP009.htm#SSEC002.11">9.2.11</a> | |
| 39 | <dt>FpfRepresentationsCyclic <a href="CHAP009.htm#SSEC002.7">9.2.7</a> | |
| 40 | <dt>FpfRepresentationsMetacyclic <a href="CHAP009.htm#SSEC002.8">9.2.8</a> | |
| 41 | <dt>FrobeniusGroup <a href="CHAP009.htm#SSEC001.3">9.1.3</a> | |
| 42 | <dt>Functions for N-groups <a href="CHAP008.htm#SECT003">8.3</a> | |
| 43 | </dl><p> | |
| 44 | [<a href="chapters.htm">Up</a>]<p> | |
| 45 | <P> | |
| 46 | <address>SONATA manual<br>October 2018 | |
| 47 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index G</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index G</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Gamma <a href="CHAP005.htm#SSEC003.1">5.3.1</a> | |
| 26 | <dt>Generators of nearring ideals <a href="CHAP006.htm#SECT004">6.4</a> | |
| 27 | <dt>GeneratorsOfNearRing <a href="CHAP002.htm#SSEC009.1">2.9.1</a> | |
| 28 | <dt>GeneratorsOfNearRingIdeal <a href="CHAP006.htm#SSEC004.1">6.4.1</a> | |
| 29 | <dt>GeneratorsOfNearRingLeftIdeal <a href="CHAP006.htm#SSEC004.2">6.4.2</a> | |
| 30 | <dt>GeneratorsOfNearRingRightIdeal <a href="CHAP006.htm#SSEC004.3">6.4.3</a> | |
| 31 | <dt>Graphic ideal lattices (X-GAP only) <a href="CHAP007.htm">7.0</a> | |
| 32 | <dt>GraphicIdealLattice <a href="CHAP007.htm#">7.0</a> | |
| 33 | <dt>GraphOfMapping <a href="CHAP004.htm#SSEC004.1">4.4.1</a> | |
| 34 | <dt>Group automorphisms <a href="CHAP001.htm#SECT004">1.4</a> | |
| 35 | <dt>Group endomorphisms <a href="CHAP001.htm#SECT003">1.3</a> | |
| 36 | <dt>Group reducts of ideals <a href="CHAP006.htm#SECT009">6.9</a> | |
| 37 | <dt>GroupReduct <a href="CHAP002.htm#SSEC011.1">2.11.1</a> | |
| 38 | <dt>GroupReduct, near ring ideals <a href="CHAP006.htm#SSEC009.1">6.9.1</a> | |
| 39 | </dl><p> | |
| 40 | [<a href="chapters.htm">Up</a>]<p> | |
| 41 | <P> | |
| 42 | <address>SONATA manual<br>October 2018 | |
| 43 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index I</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index I</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Ideals of N-groups <a href="CHAP008.htm#SECT006">8.6</a> | |
| 26 | <dt>IdempotentElements <a href="CHAP002.htm#SSEC022.2">2.22.2</a> | |
| 27 | <dt>Identifying nearrings <a href="CHAP003.htm#SECT002">3.2</a> | |
| 28 | <dt>Identity <a href="CHAP002.htm#SSEC019.1">2.19.1</a> | |
| 29 | <dt>Identity of a nearring <a href="CHAP002.htm#SECT019">2.19</a> | |
| 30 | <dt>IdentityEndoMapping <a href="CHAP004.htm#SSEC001.6">4.1.6</a> | |
| 31 | <dt>IdLibraryNearRing <a href="CHAP003.htm#SSEC002.1">3.2.1</a> | |
| 32 | <dt>IdLibraryNearRingWithOne <a href="CHAP003.htm#SSEC002.2">3.2.2</a> | |
| 33 | <dt>IdTWGroup <a href="CHAP001.htm#SSEC001.2">1.1.2</a> | |
| 34 | <dt>in <a href="CHAP006.htm#SSEC007.1">6.7.1</a> | |
| 35 | <dt>IncidenceMat <a href="CHAP011.htm#SSEC002.4">11.2.4</a> | |
| 36 | <dt>Inner automorphisms of a group <a href="CHAP001.htm#SECT005">1.5</a> | |
| 37 | <dt>InnerAutomorphismNearRing <a href="CHAP005.htm#SSEC002.7">5.2.7</a> | |
| 38 | <dt>InnerAutomorphisms <a href="CHAP001.htm#SSEC005.1">1.5.1</a> | |
| 39 | <dt>Intersection <a href="CHAP006.htm#SSEC011.2">6.11.2</a> | |
| 40 | <dt>Intersection of nearrings <a href="CHAP002.htm#SECT018">2.18</a> | |
| 41 | <dt>Intersection, for nearring ideals <a href="CHAP006.htm#SSEC011.1">6.11.1</a> | |
| 42 | <dt>Intersection, for nearrings <a href="CHAP002.htm#SSEC018.1">2.18.1</a> | |
| 43 | <dt>Invariant subgroups <a href="CHAP001.htm#SECT009">1.9</a> | |
| 44 | <dt>Invariant subnearrings <a href="CHAP002.htm#SECT016">2.16</a> | |
| 45 | <dt>InvariantSubNearRings <a href="CHAP002.htm#SSEC016.1">2.16.1</a> | |
| 46 | <dt>Is1AffineComplete <a href="CHAP005.htm#SSEC002.11">5.2.11</a> | |
| 47 | <dt>Is2TameNGroup <a href="CHAP008.htm#SSEC007.3">8.7.3</a> | |
| 48 | <dt>Is3TameNGroup <a href="CHAP008.htm#SSEC007.4">8.7.4</a> | |
| 49 | <dt>IsAbelianNearRing <a href="CHAP002.htm#SSEC023.1">2.23.1</a> | |
| 50 | <dt>IsAbstractAffineNearRing <a href="CHAP002.htm#SSEC023.2">2.23.2</a> | |
| 51 | <dt>IsBooleanNearRing <a href="CHAP002.htm#SSEC023.3">2.23.3</a> | |
| 52 | <dt>IsCharacteristicInParent <a href="CHAP001.htm#SSEC009.3">1.9.3</a> | |
| 53 | <dt>IsCharacteristicSubgroup <a href="CHAP001.htm#SSEC009.2">1.9.2</a> | |
| 54 | <dt>IsCircularDesign <a href="CHAP011.htm#SSEC002.7">11.2.7</a> | |
| 55 | <dt>IsCommutative <a href="CHAP002.htm#SSEC023.7">2.23.7</a> | |
| 56 | <dt>IsCompatible <a href="CHAP008.htm#SSEC007.1">8.7.1</a> | |
| 57 | <dt>IsCompatibleEndoMapping <a href="CHAP005.htm#SSEC002.10">5.2.10</a> | |
| 58 | <dt>IsConstantEndoMapping <a href="CHAP004.htm#SSEC002.2">4.2.2</a> | |
| 59 | <dt>IsDgNearRing <a href="CHAP002.htm#SSEC023.8">2.23.8</a> | |
| 60 | <dt>IsDistributiveEndoMapping <a href="CHAP004.htm#SSEC002.3">4.2.3</a> | |
| 61 | <dt>IsDistributiveNearRing <a href="CHAP002.htm#SSEC021.3">2.21.3</a> | |
| 62 | <dt>IsEndoMapping <a href="CHAP004.htm#SSEC001.5">4.1.5</a> | |
| 63 | <dt>IsExplicitMultiplicationNearRing <a href="CHAP002.htm#SSEC002.4">2.2.4</a> | |
| 64 | <dt>IsFpfAutomorphismGroup <a href="CHAP009.htm#SSEC001.1">9.1.1</a> | |
| 65 | <dt>IsFpfRepresentation <a href="CHAP009.htm#SSEC002.1">9.2.1</a> | |
| 66 | <dt>IsFullinvariant <a href="CHAP001.htm#SSEC009.4">1.9.4</a> | |
| 67 | <dt>IsFullinvariantInParent <a href="CHAP001.htm#SSEC009.5">1.9.5</a> | |
| 68 | <dt>IsFullTransformationNearRing <a href="CHAP005.htm#SSEC002.3">5.2.3</a> | |
| 69 | <dt>IsIdentityEndoMapping <a href="CHAP004.htm#SSEC002.1">4.2.1</a> | |
| 70 | <dt>IsIntegralNearRing <a href="CHAP002.htm#SSEC023.9">2.23.9</a> | |
| 71 | <dt>IsInvariantUnderMaps <a href="CHAP001.htm#SSEC009.1">1.9.1</a> | |
| 72 | <dt>IsIsomorphicGroup <a href="CHAP001.htm#SSEC006.1">1.6.1</a> | |
| 73 | <dt>IsIsomorphicNearRing <a href="CHAP002.htm#SSEC014.1">2.14.1</a> | |
| 74 | <dt>IsLibraryNearRing <a href="CHAP003.htm#SECT003">3.3</a> <a href="CHAP003.htm#SSEC003.1">3.3.1</a> | |
| 75 | <dt>IsMaximalNearRingIdeal <a href="CHAP006.htm#SSEC003.2">6.3.2</a> | |
| 76 | <dt>IsMonogenic <a href="CHAP008.htm#SSEC007.5">8.7.5</a> | |
| 77 | <dt>IsN0SimpleNGroup <a href="CHAP008.htm#SSEC006.5">8.6.5</a> | |
| 78 | <dt>IsNearField <a href="CHAP002.htm#SSEC023.13">2.23.13</a> | |
| 79 | <dt>IsNearRing <a href="CHAP002.htm#SSEC002.3">2.2.3</a> | |
| 80 | <dt>IsNearRingIdeal <a href="CHAP006.htm#SSEC002.4">6.2.4</a> | |
| 81 | <dt>IsNearRingLeftIdeal <a href="CHAP006.htm#SSEC002.2">6.2.2</a> | |
| 82 | <dt>IsNearRingMultiplication <a href="CHAP002.htm#SSEC001.1">2.1.1</a> | |
| 83 | <dt>IsNearRingRightIdeal <a href="CHAP006.htm#SSEC002.3">6.2.3</a> | |
| 84 | <dt>IsNearRingUnit <a href="CHAP002.htm#SSEC020.1">2.20.1</a> | |
| 85 | <dt>IsNearRingWithOne <a href="CHAP002.htm#SSEC019.3">2.19.3</a> | |
| 86 | <dt>IsNGroup <a href="CHAP008.htm#SSEC003.1">8.3.1</a> | |
| 87 | <dt>IsNIdeal <a href="CHAP008.htm#SSEC006.3">8.6.3</a> | |
| 88 | <dt>IsNilNearRing <a href="CHAP002.htm#SSEC023.4">2.23.4</a> | |
| 89 | <dt>IsNilpotentFreeNearRing <a href="CHAP002.htm#SSEC023.6">2.23.6</a> | |
| 90 | <dt>IsNilpotentNearRing <a href="CHAP002.htm#SSEC023.5">2.23.5</a> | |
| 91 | <dt>IsNRI <a href="CHAP006.htm#SSEC002.1">6.2.1</a> | |
| 92 | <dt>IsNSubgroup <a href="CHAP008.htm#SSEC004.3">8.4.3</a> | |
| 93 | <dt>Isomorphic groups <a href="CHAP001.htm#SECT006">1.6</a> | |
| 94 | <dt>Isomorphic nearrings <a href="CHAP002.htm#SECT014">2.14</a> | |
| 95 | <dt>IsPairOfDicksonNumbers <a href="CHAP010.htm#SSEC001.1">10.1.1</a> | |
| 96 | <dt>IsPlanarNearRing <a href="CHAP002.htm#SSEC023.14">2.23.14</a> | |
| 97 | <dt>IsPointIncidentBlock <a href="CHAP011.htm#SSEC003.1">11.3.1</a> | |
| 98 | <dt>IsPrimeNearRing <a href="CHAP002.htm#SSEC023.10">2.23.10</a> | |
| 99 | <dt>IsPrimeNearRingIdeal <a href="CHAP006.htm#SSEC003.1">6.3.1</a> | |
| 100 | <dt>IsQuasiregularNearRing <a href="CHAP002.htm#SSEC023.11">2.23.11</a> | |
| 101 | <dt>IsRegularNearRing <a href="CHAP002.htm#SSEC023.12">2.23.12</a> | |
| 102 | <dt>IsSimpleNearRing <a href="CHAP006.htm#SSEC013.1">6.13.1</a> | |
| 103 | <dt>IsSimpleNGroup <a href="CHAP008.htm#SSEC006.4">8.6.4</a> | |
| 104 | <dt>IsStronglyMonogenic <a href="CHAP008.htm#SSEC007.6">8.7.6</a> | |
| 105 | <dt>IsSubgroupNearRingLeftIdeal <a href="CHAP006.htm#SSEC002.5">6.2.5</a> | |
| 106 | <dt>IsSubgroupNearRingRightIdeal <a href="CHAP006.htm#SSEC002.6">6.2.6</a> | |
| 107 | <dt>IsTameNGroup <a href="CHAP008.htm#SSEC007.2">8.7.2</a> | |
| 108 | <dt>IsWdNearRing <a href="CHAP002.htm#SSEC023.15">2.23.15</a> | |
| 109 | </dl><p> | |
| 110 | [<a href="chapters.htm">Up</a>]<p> | |
| 111 | <P> | |
| 112 | <address>SONATA manual<br>October 2018 | |
| 113 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index L</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index L</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>LibraryNearRing <a href="CHAP003.htm#SSEC001.1">3.1.1</a> | |
| 26 | <dt>LibraryNearRingInfo <a href="CHAP003.htm#SSEC004.1">3.4.1</a> | |
| 27 | <dt>LibraryNearRingWithOne <a href="CHAP003.htm#SSEC001.4">3.1.4</a> | |
| 28 | <dt>LocalInterpolationNearRing <a href="CHAP005.htm#SSEC002.14">5.2.14</a> | |
| 29 | </dl><p> | |
| 30 | [<a href="chapters.htm">Up</a>]<p> | |
| 31 | <P> | |
| 32 | <address>SONATA manual<br>October 2018 | |
| 33 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index M</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index M</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>MapNearRing <a href="CHAP005.htm#SSEC002.1">5.2.1</a> | |
| 26 | <dt>Membership of an ideal <a href="CHAP006.htm#SECT007">6.7</a> | |
| 27 | <dt>Modified symbols for the operation tables <a href="CHAP002.htm#SECT005">2.5</a> | |
| 28 | </dl><p> | |
| 29 | [<a href="chapters.htm">Up</a>]<p> | |
| 30 | <P> | |
| 31 | <address>SONATA manual<br>October 2018 | |
| 32 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index N</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index N</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>N-groups <a href="CHAP008.htm">8.0</a> | |
| 26 | <dt>N-subgroups <a href="CHAP008.htm#SECT004">8.4</a> | |
| 27 | <dt>N0-subgroups <a href="CHAP008.htm#SECT005">8.5</a> | |
| 28 | <dt>N0Subgroups <a href="CHAP008.htm#SSEC005.1">8.5.1</a> | |
| 29 | <dt>Near-ring ideal elements <a href="CHAP006.htm#SECT005">6.5</a> | |
| 30 | <dt>Nearfields, planar nearrings and weakly divisible nearrings <a href="CHAP010.htm">10.0</a> | |
| 31 | <dt>Nearring automorphisms <a href="CHAP002.htm#SECT013">2.13</a> | |
| 32 | <dt>Nearring elements <a href="CHAP002.htm#SECT007">2.7</a> | |
| 33 | <dt>Nearring endomorphisms <a href="CHAP002.htm#SECT012">2.12</a> | |
| 34 | <dt>Nearring generators <a href="CHAP002.htm#SECT009">2.9</a> | |
| 35 | <dt>Nearring ideals <a href="CHAP006.htm">6.0</a> | |
| 36 | <dt>Nearring radicals <a href="CHAP008.htm#SECT009">8.9</a> | |
| 37 | <dt>NearRingActingOnNGroup <a href="CHAP008.htm#SSEC003.2">8.3.2</a> | |
| 38 | <dt>NearRingCommutator <a href="CHAP006.htm#SSEC012.1">6.12.1</a> | |
| 39 | <dt>NearRingIdealByGenerators <a href="CHAP006.htm#SSEC001.1">6.1.1</a> | |
| 40 | <dt>NearRingIdealBySubgroupNC <a href="CHAP006.htm#SSEC001.4">6.1.4</a> | |
| 41 | <dt>NearRingIdeals <a href="CHAP006.htm#SSEC001.7">6.1.7</a> | |
| 42 | <dt>NearRingLeftIdealByGenerators <a href="CHAP006.htm#SSEC001.2">6.1.2</a> | |
| 43 | <dt>NearRingLeftIdealBySubgroupNC <a href="CHAP006.htm#SSEC001.5">6.1.5</a> | |
| 44 | <dt>NearRingLeftIdeals <a href="CHAP006.htm#SSEC001.8">6.1.8</a> | |
| 45 | <dt>NearRingMultiplicationByOperationTable <a href="CHAP002.htm#SSEC001.2">2.1.2</a> | |
| 46 | <dt>NearRingRightIdealByGenerators <a href="CHAP006.htm#SSEC001.3">6.1.3</a> | |
| 47 | <dt>NearRingRightIdealBySubgroupNC <a href="CHAP006.htm#SSEC001.6">6.1.6</a> | |
| 48 | <dt>NearRingRightIdeals <a href="CHAP006.htm#SSEC001.9">6.1.9</a> | |
| 49 | <dt>Nearrings <a href="CHAP002.htm">2.0</a> | |
| 50 | <dt>Nearrings of transformations <a href="CHAP005.htm#SECT002">5.2</a> | |
| 51 | <dt>NearRingUnits <a href="CHAP002.htm#SSEC020.2">2.20.2</a> | |
| 52 | <dt>NGroup <a href="CHAP008.htm#SSEC001.1">8.1.1</a> | |
| 53 | <dt>NGroupByApplication <a href="CHAP008.htm#SSEC001.3">8.1.3</a> | |
| 54 | <dt>NGroupByNearRingMultiplication <a href="CHAP008.htm#SSEC001.2">8.1.2</a> | |
| 55 | <dt>NGroupByRightIdealFactor <a href="CHAP008.htm#SSEC001.4">8.1.4</a> | |
| 56 | <dt>Nicer ways to print a mapping <a href="CHAP004.htm#SECT004">4.4</a> | |
| 57 | <dt>NIdeal <a href="CHAP008.htm#SSEC006.1">8.6.1</a> | |
| 58 | <dt>NIdeals <a href="CHAP008.htm#SSEC006.2">8.6.2</a> | |
| 59 | <dt>NilpotentElements <a href="CHAP002.htm#SSEC022.3">2.22.3</a> | |
| 60 | <dt>Noetherian quotients <a href="CHAP008.htm#SECT008">8.8</a> | |
| 61 | <dt>Noetherian quotients for transformation nearrings <a href="CHAP005.htm#SECT005">5.5</a> | |
| 62 | <dt>NoetherianQuotient <a href="CHAP008.htm#SSEC008.1">8.8.1</a> | |
| 63 | <dt>NoetherianQuotient, for transformation nearrings <a href="CHAP005.htm#SSEC005.1">5.5.1</a> | |
| 64 | <dt>NontrivialRepresentativesModNormalSubgroup <a href="CHAP001.htm#SSEC010.2">1.10.2</a> | |
| 65 | <dt>Normal subgroups generated by a single element <a href="CHAP001.htm#SECT008">1.8</a> | |
| 66 | <dt>NSubgroup <a href="CHAP008.htm#SSEC004.1">8.4.1</a> | |
| 67 | <dt>NSubgroups <a href="CHAP008.htm#SSEC004.2">8.4.2</a> | |
| 68 | <dt>NumberLibraryNearRings <a href="CHAP003.htm#SSEC001.2">3.1.2</a> | |
| 69 | <dt>NumberLibraryNearRingsWithOne <a href="CHAP003.htm#SSEC001.5">3.1.5</a> | |
| 70 | <dt>NumberOfDicksonNearFields <a href="CHAP010.htm#SSEC002.2">10.2.2</a> | |
| 71 | <dt>NuRadical <a href="CHAP008.htm#SSEC009.1">8.9.1</a> | |
| 72 | <dt>NuRadicals <a href="CHAP008.htm#SSEC009.2">8.9.2</a> | |
| 73 | </dl><p> | |
| 74 | [<a href="chapters.htm">Up</a>]<p> | |
| 75 | <P> | |
| 76 | <address>SONATA manual<br>October 2018 | |
| 77 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index O</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index O</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>One <a href="CHAP002.htm#SSEC019.2">2.19.2</a> | |
| 26 | <dt>OneGeneratedNormalSubgroups <a href="CHAP001.htm#SSEC008.1">1.8.1</a> | |
| 27 | <dt>Operation tables for groups <a href="CHAP001.htm#SECT002">1.2</a> | |
| 28 | <dt>Operation tables for nearrings <a href="CHAP002.htm#SECT004">2.4</a> | |
| 29 | <dt>Operation tables of N-groups <a href="CHAP008.htm#SECT002">8.2</a> | |
| 30 | <dt>Operations for endo mappings <a href="CHAP004.htm#SECT003">4.3</a> | |
| 31 | <dt>Operations with ideals <a href="CHAP006.htm#SECT011">6.11</a> | |
| 32 | <dt>OrbitRepresentativesForPlanarNearRing <a href="CHAP010.htm#SSEC004.2">10.4.2</a> | |
| 33 | <dt>Other useful functions for groups <a href="CHAP001.htm#SECT012">1.12</a> | |
| 34 | </dl><p> | |
| 35 | [<a href="chapters.htm">Up</a>]<p> | |
| 36 | <P> | |
| 37 | <address>SONATA manual<br>October 2018 | |
| 38 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index P</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index P</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Planar nearrings <a href="CHAP010.htm#SECT004">10.4</a> | |
| 26 | <dt>PlanarNearRing <a href="CHAP010.htm#SSEC004.1">10.4.1</a> | |
| 27 | <dt>PointsIncidentBlocks <a href="CHAP011.htm#SSEC003.2">11.3.2</a> | |
| 28 | <dt>PointsOfDesign <a href="CHAP011.htm#SSEC002.1">11.2.1</a> | |
| 29 | <dt>PolynomialNearRing <a href="CHAP005.htm#SSEC002.4">5.2.4</a> | |
| 30 | <dt>Predefined groups <a href="CHAP001.htm#SECT001">1.1</a> | |
| 31 | <dt>PrintAsTerm <a href="CHAP004.htm#SSEC004.2">4.4.2</a> | |
| 32 | <dt>PrintIncidenceMat <a href="CHAP011.htm#SSEC002.5">11.2.5</a> | |
| 33 | <dt>PrintTable <a href="CHAP001.htm#SSEC002.1">1.2.1</a> | |
| 34 | <dt>PrintTable, for N-groups <a href="CHAP008.htm#SSEC002.1">8.2.1</a> | |
| 35 | <dt>PrintTable, near rings <a href="CHAP002.htm#SSEC004.1">2.4.1</a> | |
| 36 | <dt>Properties of a design <a href="CHAP011.htm#SECT002">11.2</a> | |
| 37 | <dt>Properties of endo mappings <a href="CHAP004.htm#SECT002">4.2</a> | |
| 38 | </dl><p> | |
| 39 | [<a href="chapters.htm">Up</a>]<p> | |
| 40 | <P> | |
| 41 | <address>SONATA manual<br>October 2018 | |
| 42 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index Q</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index Q</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>QuasiregularElements <a href="CHAP002.htm#SSEC022.4">2.22.4</a> | |
| 26 | </dl><p> | |
| 27 | [<a href="chapters.htm">Up</a>]<p> | |
| 28 | <P> | |
| 29 | <address>SONATA manual<br>October 2018 | |
| 30 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index R</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index R</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Random ideal elements <a href="CHAP006.htm#SECT006">6.6</a> | |
| 26 | <dt>Random nearring elements <a href="CHAP002.htm#SECT008">2.8</a> | |
| 27 | <dt>Random, near ring element <a href="CHAP002.htm#SSEC008.1">2.8.1</a> | |
| 28 | <dt>Random, near ring ideal element <a href="CHAP006.htm#SSEC006.1">6.6.1</a> | |
| 29 | <dt>RegularElements <a href="CHAP002.htm#SSEC022.5">2.22.5</a> | |
| 30 | <dt>RepresentativesModNormalSubgroup <a href="CHAP001.htm#SSEC010.1">1.10.1</a> | |
| 31 | <dt>RestrictedEndomorphismNearRing <a href="CHAP005.htm#SSEC002.13">5.2.13</a> | |
| 32 | </dl><p> | |
| 33 | [<a href="chapters.htm">Up</a>]<p> | |
| 34 | <P> | |
| 35 | <address>SONATA manual<br>October 2018 | |
| 36 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index S</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index S</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Scott length <a href="CHAP001.htm#SECT011">1.11</a> | |
| 26 | <dt>ScottLength <a href="CHAP001.htm#SSEC011.1">1.11.1</a> | |
| 27 | <dt>SetSymbols <a href="CHAP002.htm#SSEC005.1">2.5.1</a> | |
| 28 | <dt>SetSymbolsSupervised <a href="CHAP002.htm#SSEC005.1">2.5.1</a> | |
| 29 | <dt>Simple nearrings <a href="CHAP006.htm#SECT013">6.13</a> | |
| 30 | <dt>Size of a nearring <a href="CHAP002.htm#SECT010">2.10</a> | |
| 31 | <dt>Size of ideals <a href="CHAP006.htm#SECT008">6.8</a> | |
| 32 | <dt>Size, near ring ideals <a href="CHAP006.htm#SSEC008.1">6.8.1</a> | |
| 33 | <dt>Size, near rings <a href="CHAP002.htm#SSEC010.1">2.10.1</a> | |
| 34 | <dt>Special ideal properties <a href="CHAP006.htm#SECT003">6.3</a> | |
| 35 | <dt>Special properties of a nearring <a href="CHAP002.htm#SECT023">2.23</a> | |
| 36 | <dt>Special properties of N-groups <a href="CHAP008.htm#SECT007">8.7</a> | |
| 37 | <dt>Subgroups <a href="CHAP001.htm#SSEC007.1">1.7.1</a> | |
| 38 | <dt>Subgroups of a group <a href="CHAP001.htm#SECT007">1.7</a> | |
| 39 | <dt>SubNearRingBySubgroupNC <a href="CHAP002.htm#SSEC017.1">2.17.1</a> | |
| 40 | <dt>SubNearRings <a href="CHAP002.htm#SSEC015.1">2.15.1</a> | |
| 41 | <dt>Subnearrings <a href="CHAP002.htm#SECT015">2.15</a> | |
| 42 | <dt>Supportive functions for groups <a href="CHAP001.htm">1.0</a> | |
| 43 | <dt>Symbols <a href="CHAP002.htm#SSEC005.2">2.5.2</a> | |
| 44 | </dl><p> | |
| 45 | [<a href="chapters.htm">Up</a>]<p> | |
| 46 | <P> | |
| 47 | <address>SONATA manual<br>October 2018 | |
| 48 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index T</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index T</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Testing for ideal properties <a href="CHAP006.htm#SECT002">6.2</a> | |
| 26 | <dt>The additive group of a nearring <a href="CHAP002.htm#SECT011">2.11</a> | |
| 27 | <dt>The group a transformation nearring acts on <a href="CHAP005.htm#SECT003">5.3</a> | |
| 28 | <dt>The nearring library <a href="CHAP003.htm">3.0</a> | |
| 29 | <dt>Transformation nearrings <a href="CHAP005.htm">5.0</a> | |
| 30 | <dt>Transformation nearrings and other nearrings <a href="CHAP005.htm#SECT004">5.4</a> | |
| 31 | <dt>TransformationNearRing <a href="CHAP005.htm#SSEC002.2">5.2.2</a> | |
| 32 | <dt>TransformationNearRingByAdditiveGenerators <a href="CHAP005.htm#SSEC001.2">5.1.2</a> | |
| 33 | <dt>TransformationNearRingByGenerators <a href="CHAP005.htm#SSEC001.1">5.1.1</a> | |
| 34 | <dt>TWGroup <a href="CHAP001.htm#SSEC001.1">1.1.1</a> | |
| 35 | <dt>TypeOfNGroup <a href="CHAP008.htm#SSEC007.7">8.7.7</a> | |
| 36 | </dl><p> | |
| 37 | [<a href="chapters.htm">Up</a>]<p> | |
| 38 | <P> | |
| 39 | <address>SONATA manual<br>October 2018 | |
| 40 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index U</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index U</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Units of a nearring <a href="CHAP002.htm#SECT020">2.20</a> | |
| 26 | </dl><p> | |
| 27 | [<a href="chapters.htm">Up</a>]<p> | |
| 28 | <P> | |
| 29 | <address>SONATA manual<br>October 2018 | |
| 30 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index W</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index W</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>WdNearRing <a href="CHAP010.htm#SSEC005.1">10.5.1</a> | |
| 26 | <dt>Weakly divisible nearrings <a href="CHAP010.htm#SECT005">10.5</a> | |
| 27 | <dt>Working with the points and blocks of a design <a href="CHAP011.htm#SECT003">11.3</a> | |
| 28 | </dl><p> | |
| 29 | [<a href="chapters.htm">Up</a>]<p> | |
| 30 | <P> | |
| 31 | <address>SONATA manual<br>October 2018 | |
| 32 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index Z</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index Z</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>Zerosymmetric mappings <a href="CHAP005.htm#SECT006">5.6</a> | |
| 26 | <dt>ZeroSymmetricCompatibleFunctionNearRing <a href="CHAP005.htm#SSEC002.9">5.2.9</a> | |
| 27 | <dt>ZeroSymmetricElements <a href="CHAP002.htm#SSEC022.1">2.22.1</a> | |
| 28 | <dt>ZeroSymmetricPart, for transformation nearrings <a href="CHAP005.htm#SSEC006.1">5.6.1</a> | |
| 29 | </dl><p> | |
| 30 | [<a href="chapters.htm">Up</a>]<p> | |
| 31 | <P> | |
| 32 | <address>SONATA manual<br>October 2018 | |
| 33 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA : a GAP 4 package - Index _</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index _</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxB.htm">B</A> | |
| 7 | <a href="indxC.htm">C</A> | |
| 8 | <a href="indxD.htm">D</A> | |
| 9 | <a href="indxE.htm">E</A> | |
| 10 | <a href="indxF.htm">F</A> | |
| 11 | <a href="indxG.htm">G</A> | |
| 12 | <a href="indxI.htm">I</A> | |
| 13 | <a href="indxL.htm">L</A> | |
| 14 | <a href="indxM.htm">M</A> | |
| 15 | <a href="indxN.htm">N</A> | |
| 16 | <a href="indxO.htm">O</A> | |
| 17 | <a href="indxP.htm">P</A> | |
| 18 | <a href="indxQ.htm">Q</A> | |
| 19 | <a href="indxR.htm">R</A> | |
| 20 | <a href="indxS.htm">S</A> | |
| 21 | <a href="indxT.htm">T</A> | |
| 22 | <a href="indxU.htm">U</A> | |
| 23 | <a href="indxW.htm">W</A> | |
| 24 | <a href="indxZ.htm">Z</A> | |
| 25 | <dt>/ <a href="CHAP006.htm#SSEC014.2">6.14.2</a> | |
| 26 | <dt>= <a href="CHAP006.htm#SSEC010.1">6.10.1</a> | |
| 27 | </dl><p> | |
| 28 | [<a href="chapters.htm">Up</a>]<p> | |
| 29 | <P> | |
| 30 | <address>SONATA manual<br>October 2018 | |
| 31 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 1 Groups</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>1 Groups</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP001.htm#SECT001">Thomas' and Wood's catalogue of small groups</a> | |
| 8 | <li> <A HREF="CHAP001.htm#SECT002">Subgroups</a> | |
| 9 | <li> <A HREF="CHAP001.htm#SECT003">Group endomorphisms</a> | |
| 10 | <li> <A HREF="CHAP001.htm#SECT004">Finding a set of generators</a> | |
| 11 | </ol><p> | |
| 12 | <p> | |
| 13 | SONATA adds some functions for groups. To use the functions provided by | |
| 14 | SONATA, one has to load it into GAP: | |
| 15 | <pre> | |
| 16 | gap> LoadPackage( "sonata" ); | |
| 17 | </pre> | |
| 18 | <p> | |
| 19 | <p> | |
| 20 | <h2><a name="SECT001">1.1 Thomas' and Wood's catalogue of small groups</a></h2> | |
| 21 | <p><p> | |
| 22 | Most of the nonabelian groups (even small ones) do not have a | |
| 23 | popular name (as <i>S</i><sub>3</sub> or <i>A</i><sub>4</sub>). We like to give unique names to | |
| 24 | the groups we are working with. The book ``Group Tables'' by | |
| 25 | Thomas and Wood classifies all groups up to order 32. In this book | |
| 26 | every group has a name of the form <code>m/n</code>, where <code>m</code> is the order of | |
| 27 | the group and <code>n</code> the number of the particular group of order <code>m</code>. | |
| 28 | The cyclic groups have the name <code>m/1</code>. Then come the abelian groups, | |
| 29 | finally the non-abelian ones. To find out the name of a given group | |
| 30 | in their book we use <code>IdTWGroup</code>. | |
| 31 | <pre> | |
| 32 | gap> G := DihedralGroup( 8 ); | |
| 33 | <pc group of size 8 with 3 generators> | |
| 34 | gap> IdTWGroup( G ); | |
| 35 | [ 8, 4 ] | |
| 36 | </pre> | |
| 37 | If we want to refer to the group with the name <code>8/4</code> directly we | |
| 38 | say | |
| 39 | <pre> | |
| 40 | gap> H := TWGroup( 8, 4 ); | |
| 41 | 8/4 | |
| 42 | </pre> | |
| 43 | Groups which are obtained in this way always come as a group of | |
| 44 | permutations. We can have a look at the elements of <var>H</var> if we ask | |
| 45 | for <var>H</var> as a list. | |
| 46 | <pre> | |
| 47 | gap> AsList( H ); | |
| 48 | [ (), (2,4), (1,2)(3,4), (1,2,3,4), (1,3), (1,3)(2,4), (1,4,3,2), | |
| 49 | (1,4)(2,3) ] | |
| 50 | </pre> | |
| 51 | Clearly, <var>G</var> and <var>H</var> are not equal but they are isomorphic. If we want | |
| 52 | to know what the isomorphism between the two looks like, we use | |
| 53 | <code>IsomorphismGroups</code>. Note, that a homomorphism is determined by the | |
| 54 | images of the generators. | |
| 55 | <pre> | |
| 56 | gap> IsomorphismGroups(G,H); | |
| 57 | [ f1, f2, f3 ] -> [ (2,4), (1,2,3,4), (1,3)(2,4) ] | |
| 58 | </pre> | |
| 59 | How many nonisomorphic groups are there of order <var>n</var>? Up to order | |
| 60 | 1000 the function <code>NumberSmallGroups</code> gives the answer. As a shortcut | |
| 61 | for <code>TWGroup( 32, 46 )</code> we may also type <code>GTW32_46</code>. | |
| 62 | <pre> | |
| 63 | gap> NumberSmallGroups( 32 ); | |
| 64 | 51 | |
| 65 | gap> GTW32_46; | |
| 66 | 32/46 | |
| 67 | gap> GTW32_46 = TWGroup( 32, 46 ); | |
| 68 | true | |
| 69 | </pre> | |
| 70 | Now we find all nonabelian groups with trivial centre of order at most | |
| 71 | 32. We use <code>GroupList</code>, a list of all groups up to order 32 and filter | |
| 72 | out the nonabelian ones with trivial center. | |
| 73 | <pre> | |
| 74 | gap> Filtered( GroupList, g -> not IsAbelian( g ) and | |
| 75 | > Size(Centre( g ))=1 ); | |
| 76 | [ 6/2, 10/2, 12/4, 14/2, 18/4, 18/5, 20/5, 21/2, 22/2, 24/12, 26/2, | |
| 77 | 30/4 ] | |
| 78 | </pre> | |
| 79 | This was the first time that we have used a function as an argument. | |
| 80 | The second argument of the function <code>Filtered</code> is a function | |
| 81 | (<code>g -> not ...</code>), which returns for every <code>g</code> the boolean value <code>true</code> | |
| 82 | if <code>g</code> is not abelian and the size of its centre is 1, and <code>false</code> | |
| 83 | otherwise. This is the easiest way to write a function. | |
| 84 | <p> | |
| 85 | <p> | |
| 86 | <h2><a name="SECT002">1.2 Subgroups</a></h2> | |
| 87 | <p><p> | |
| 88 | The function <code>Subgroups</code> returns a list of all subgroups of a group. | |
| 89 | We can use this function and the <code>Filtered</code> command to determine all | |
| 90 | characteristic subgroups of the dihedral group of order 16. | |
| 91 | <pre> | |
| 92 | gap> D16 := DihedralGroup( 16 ); | |
| 93 | <pc group of size 16 with 4 generators> | |
| 94 | gap> S := Subgroups( D16 ); | |
| 95 | [ Group([ ]), Group([ f4 ]), Group([ f1 ]), Group([ f1*f3 ]), | |
| 96 | Group([ f1*f4 ]), Group([ f1*f3*f4 ]), Group([ f1*f2 ]), | |
| 97 | Group([ f1*f2*f3 ]), Group([ f1*f2*f4 ]), | |
| 98 | Group([ f1*f2*f3*f4 ]), Group([ f4, f3 ]), Group([ f4, f1 ]), | |
| 99 | Group([ f1*f3, f4 ]), Group([ f4, f1*f2 ]), | |
| 100 | Group([ f1*f2*f3, f4 ]), Group([ f4, f3, f1 ]), | |
| 101 | Group([ f4, f3, f2 ]), Group([ f4, f3, f1*f2 ]), | |
| 102 | Group([ f4, f3, f1, f2 ]) ] | |
| 103 | gap> C := Filtered( S, G -> IsCharacteristicInParent( G ) ); | |
| 104 | [ Group([ ]), Group([ f4 ]), Group([ f4, f3 ]), Group([ f4, f3, f2 ]), | |
| 105 | Group([ f4, f3, f1, f2 ]) ] | |
| 106 | </pre> | |
| 107 | <p> | |
| 108 | <p> | |
| 109 | <h2><a name="SECT003">1.3 Group endomorphisms</a></h2> | |
| 110 | <p><p> | |
| 111 | Everybody knows that every automorphism of the symmetric group <i>S</i><sub>3</sub> | |
| 112 | (= <code>GTW6_2</code>) fixes a point (besides the identity of the group). But, | |
| 113 | are there endomorphisms which fix nothing but the identity? We are | |
| 114 | going to simply try it out. On our way we will find out that all | |
| 115 | automorphisms of <i>S</i><sub>3</sub> are inner automorphisms. | |
| 116 | <pre> | |
| 117 | gap> G := GTW6_2; | |
| 118 | 6/2 | |
| 119 | gap> Automorphisms( G ); | |
| 120 | [ IdentityMapping( 6/2 ), ^(2,3), ^(1,3), ^(1,3,2), ^(1,2,3), ^(1,2) ] | |
| 121 | gap> Endos := Endomorphisms( G ); | |
| 122 | [ [ (1,2), (1,2,3) ] -> [ (), () ], [ (1,2), (1,2,3) ] -> [ (2,3), () ], | |
| 123 | [ (1,2), (1,2,3) ] -> [ (1,3), () ], [ (1,2), (1,2,3) ] -> [ (1,2), () ], | |
| 124 | [ (1,2), (1,2,3) ] -> [ (2,3), (1,2,3) ], | |
| 125 | [ (1,2), (1,2,3) ] -> [ (2,3), (1,3,2) ], | |
| 126 | [ (1,2), (1,2,3) ] -> [ (1,2), (1,3,2) ], | |
| 127 | [ (1,2), (1,2,3) ] -> [ (1,2), (1,2,3) ], | |
| 128 | [ (1,2), (1,2,3) ] -> [ (1,3), (1,2,3) ], | |
| 129 | [ (1,2), (1,2,3) ] -> [ (1,3), (1,3,2) ] ] | |
| 130 | </pre> | |
| 131 | Now it is time for real programming, but don't worry, it is all very | |
| 132 | simple. We write a function which decides whether an endomorphism | |
| 133 | fixes a point besides the identity or not (in the latter case we | |
| 134 | call the endomorphism <strong>fixed-point-free</strong>). | |
| 135 | <pre> | |
| 136 | gap> IsFixedpointfree := function( endo ) | |
| 137 | >local group; | |
| 138 | > group := Source( endo ); # the domain of endo | |
| 139 | > return ForAll( group, x -> (x <> x^endo) or (x = Identity(group)) ); | |
| 140 | > # x is not fixed or x is the identity | |
| 141 | >end; | |
| 142 | function ( endo ) ... end | |
| 143 | </pre> | |
| 144 | This paragraph says that <code>IsFixedpointfree</code> is a function that takes | |
| 145 | one argument (called <code>endo</code>). Now we create a local variable <code>group</code> to | |
| 146 | store the group on which the endomorphism acts (in our example this | |
| 147 | will always be <i>S</i><sub>3</sub>, but maybe we want to use this function for | |
| 148 | other groups, too). Local means that <font face="Gill Sans,Helvetica,Arial">GAP</font> may forget this variable | |
| 149 | as soon as it has computed what we want (and it will forget it | |
| 150 | instantly afterwards). Now we store the domain of <code>endo</code> in the | |
| 151 | variable <code>group</code>. The next line already returns the result. It returns | |
| 152 | <code>true</code> if for all elements <code>x</code> of <code>group</code> either <code>x</code> is not fixed | |
| 153 | by <code>endo</code> or <code>x</code> is the identity of the group. This line is a | |
| 154 | one-to-one translation of the logical statement that <code>endo</code> is | |
| 155 | fixed-point-free. | |
| 156 | <p> | |
| 157 | The result is a function which can be applied to any endomorphism, now. | |
| 158 | For example we can ask if the fourth endomorphism in the list <code>E</code> is | |
| 159 | fixed-point-free. | |
| 160 | <pre> | |
| 161 | gap> e := Endos[4]; | |
| 162 | [ (1,2), (1,2,3) ] -> [ (1,2), () ] | |
| 163 | gap> IsFixedpointfree( e ); | |
| 164 | false | |
| 165 | </pre> | |
| 166 | Now we filter out the fixed-point-free endomorphisms. | |
| 167 | <pre> | |
| 168 | gap> Filtered( Endos, IsFixedpointfree ); | |
| 169 | [ [ (1,2), (1,2,3) ] -> [ (), () ] ] | |
| 170 | </pre> | |
| 171 | <p> | |
| 172 | <p> | |
| 173 | <h2><a name="SECT004">1.4 Finding a set of generators</a></h2> | |
| 174 | <p><p> | |
| 175 | It is well known that for any finite p-group <i>G</i> the factor <i>G</i>/<font face="symbol">F</font>(<i>G</i>) | |
| 176 | modulo the Frattini subgroup <font face="symbol">F</font>(<i>G</i>) has order <i>p</i><sup><font face="symbol">d</font>(<i>G</i>)</sup>, where | |
| 177 | <font face="symbol">d</font>(<i>G</i>) is the minimal number of generators of <i>G</i>. Moreover | |
| 178 | the representatives of the residue classes modulo <font face="symbol">F</font>(<i>G</i>) form a | |
| 179 | set of generators. So a generating set for a <i>p</i>-group | |
| 180 | could be obtained in the following way. We choose the group 16/11 (a | |
| 181 | semidirect product of the cyclic group of order 8 with the cyclic | |
| 182 | group of order 2). | |
| 183 | <pre> | |
| 184 | gap> G := GTW16_11; | |
| 185 | 16/11 | |
| 186 | gap> F := FrattiniSubgroup( G ); | |
| 187 | Group([ (1,4,11,14)(2,7,10,16)(3,8,15,9)(5,12,6,13) ]) | |
| 188 | gap> NontrivialRepresentativesModNormalSubgroup( G, F ); | |
| 189 | [ (1,16,14,10,11,7,4,2)(3,12,9,5,15,13,8,6), | |
| 190 | (1,3)(2,5)(4,8)(6,10)(7,12)(9,14)(11,15)(13,16), | |
| 191 | (1,13,4,5,11,12,14,6)(2,3,7,8,10,15,16,9) ] | |
| 192 | gap> H := Group( last ); | |
| 193 | Group([ (1,16,14,10,11,7,4,2)(3,12,9,5,15,13,8,6), | |
| 194 | (1,3)(2,5)(4,8)(6,10)(7,12)(9,14)(11,15)(13,16), | |
| 195 | (1,13,4,5,11,12,14,6)(2,3,7,8,10,15,16,9) ]) | |
| 196 | gap> G = H; # test | |
| 197 | true | |
| 198 | </pre> | |
| 199 | The variable <code>last</code> in the this example refers to the last result, | |
| 200 | i.e. in this case the list of representatives. | |
| 201 | <p> | |
| 202 | <p> | |
| 203 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 204 | <P> | |
| 205 | <address>SONATA-tutorial manual<br>October 2018 | |
| 206 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 2 Nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>2 Nearrings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP002.htm#SECT001">Entering nearrings into the system</a> | |
| 8 | <li> <A HREF="CHAP002.htm#SECT002">Some simple questions about the nearring</a> | |
| 9 | <li> <A HREF="CHAP002.htm#SECT003">Entering the nearring with less typing</a> | |
| 10 | </ol><p> | |
| 11 | <p> | |
| 12 | A <strong>(left) nearring</strong> is an algebra (<i>N</i>,+,*), where | |
| 13 | (<i>N</i>,+) is a (not necessarily abelian) group, | |
| 14 | (<i>N</i>,*) is a semigroup, and | |
| 15 | the distributive law <i>x</i>*(<i>y</i>+<i>z</i>) = <i>x</i>*<i>y</i>+<i>x</i>*<i>z</i> | |
| 16 | holds. | |
| 17 | Such nearrings are called <strong>left nearrings</strong>. | |
| 18 | A typical example is constructed as follows: | |
| 19 | take a group (<i>G</i>,+) (not necessarily abelian), and | |
| 20 | take the set <i>M</i>(<i>G</i>) of all mappings from <i>G</i> to <i>G</i>. | |
| 21 | Then we define + on <i>M</i>(<i>G</i>) as pointwise addition of | |
| 22 | mappings, and * by <i>m</i> * <i>n</i> (<font face="symbol">g</font>) : = <i>n</i> (<i>m</i> (<font face="symbol">g</font>)). | |
| 23 | The multiplication looks more natural if we write | |
| 24 | functions right of their arguments. Then the definition | |
| 25 | reads (<font face="symbol">g</font>) <i>m</i> * <i>n</i> = ((<font face="symbol">g</font>)<i>m</i>)<i>n</i>. | |
| 26 | <p> | |
| 27 | Textbooks on nearrings are <a href="biblio.htm#meldrum85:NATLWG"><[>meldrum85:NATLWG</cite></a>], <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>], | |
| 28 | <a href="biblio.htm#Ferrero:Nearrings"><[>Ferrero:Nearrings</cite></a>]. They all use <strong>left nearrings</strong>. | |
| 29 | The book <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>] uses <strong>right nearrings</strong>; these are | |
| 30 | the algebras that arise if we claim the right distributive law | |
| 31 | (<i>x</i> + <i>y</i>) * <i>z</i> = <i>x</i>*<i>z</i> + <i>y</i>*<i>z</i> instead of the left distributive law | |
| 32 | given above. | |
| 33 | <p> | |
| 34 | SONATA uses <strong>left</strong> nearrings throughout. | |
| 35 | <p> | |
| 36 | <p> | |
| 37 | <h2><a name="SECT001">2.1 Entering nearrings into the system</a></h2> | |
| 38 | <p><p> | |
| 39 | <strong>The problem:</strong> Input the nearring given in the example | |
| 40 | of page 406 of <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>] | |
| 41 | into SONATA. | |
| 42 | <p> | |
| 43 | This nearring is given by an explicit multiplication table. | |
| 44 | The function <code>ExplicitMultiplicationNearRing</code> can be | |
| 45 | used to do the job. | |
| 46 | But first, let's get the additive group, which is | |
| 47 | Klein's four group: | |
| 48 | <pre> | |
| 49 | gap> G := GTW4_2; | |
| 50 | 4/2 | |
| 51 | </pre> | |
| 52 | Now we have to establish a correspondence between | |
| 53 | the elements <code>0</code>, <code>a</code>, <code>b</code>, <code>c</code> of the group in the example | |
| 54 | and GAP's representation of the group elements. | |
| 55 | <pre> | |
| 56 | gap> AsSortedList( G ); | |
| 57 | [ (), (3,4), (1,2), (1,2)(3,4) ] | |
| 58 | </pre> | |
| 59 | Ok, let's map <code>0</code> to <code>()</code>, <code>a</code> to <code>(3,4)</code>, <code>b</code> to <code>(1,2)</code> | |
| 60 | and <code>c</code> to <code>(1,2)(3,4)</code> | |
| 61 | <p> | |
| 62 | <pre> | |
| 63 | gap> SetSymbols( G, [ "0", "a", "b", "c" ] ); | |
| 64 | gap> PrintTable( G ); | |
| 65 | Let: | |
| 66 | 0 := () | |
| 67 | a := (3,4) | |
| 68 | b := (1,2) | |
| 69 | c := (1,2)(3,4) | |
| 70 | ||
| 71 | + | 0 a b c | |
| 72 | ------------ | |
| 73 | 0 | 0 a b c | |
| 74 | a | a 0 c b | |
| 75 | b | b c 0 a | |
| 76 | c | c b a 0 | |
| 77 | ||
| 78 | </pre> | |
| 79 | <p> | |
| 80 | Now for entering the nearring multiplication: | |
| 81 | We will use the function <code>NrMultiplicationByOperationTable</code>. | |
| 82 | This function requires as one of its arguments a matrix | |
| 83 | of integers representing the operation table: | |
| 84 | We choose the entries of <code>table</code> according to the | |
| 85 | positions of the elements of <code>G</code> in | |
| 86 | <code>AsSortedList( G )</code>: | |
| 87 | <pre> | |
| 88 | gap> table := [ [ 1, 1, 1, 1 ], | |
| 89 | > [ 1, 1, 2, 2 ], | |
| 90 | > [ 1, 2, 4, 3 ], | |
| 91 | > [ 1, 2, 3, 4 ] ]; | |
| 92 | [ [ 1, 1, 1, 1 ], [ 1, 1, 2, 2 ], [ 1, 2, 4, 3 ], [ 1, 2, 3, 4 ] ] | |
| 93 | </pre> | |
| 94 | <p> | |
| 95 | Now we are in position to define a nearring multiplication: | |
| 96 | <pre> | |
| 97 | gap> mul:=NearRingMultiplicationByOperationTable( | |
| 98 | > G, table, AsSortedList(G) ); | |
| 99 | function( x, y ) ... end | |
| 100 | </pre> | |
| 101 | <p> | |
| 102 | And finally, we can define the nearring: | |
| 103 | <pre> | |
| 104 | gap> N := ExplicitMultiplicationNearRing( G, mul ); | |
| 105 | ExplicitMultiplicationNearRing ( 4/2 , multiplication ) | |
| 106 | </pre> | |
| 107 | We get no error message, which means that we have | |
| 108 | indeed defined a nearring multiplication on <code>G</code>. | |
| 109 | Now let's take a look at it: | |
| 110 | <pre> | |
| 111 | gap> PrintTable( N ); | |
| 112 | Let: | |
| 113 | 0 := (()) | |
| 114 | a := ((3,4)) | |
| 115 | b := ((1,2)) | |
| 116 | c := ((1,2)(3,4)) | |
| 117 | ||
| 118 | + | 0 a b c | |
| 119 | --------------- | |
| 120 | 0 | 0 a b c | |
| 121 | a | a 0 c b | |
| 122 | b | b c 0 a | |
| 123 | c | c b a 0 | |
| 124 | ||
| 125 | * | 0 a b c | |
| 126 | --------------- | |
| 127 | 0 | 0 0 0 0 | |
| 128 | a | 0 0 a a | |
| 129 | b | 0 a c b | |
| 130 | c | 0 a b c | |
| 131 | </pre> | |
| 132 | The symbols used for the elements of the group are also used for the | |
| 133 | elements of the nearring. Of course, it is still possible to redefine the | |
| 134 | symbols. | |
| 135 | <p> | |
| 136 | <p> | |
| 137 | <h2><a name="SECT002">2.2 Some simple questions about the nearring</a></h2> | |
| 138 | <p><p> | |
| 139 | Now, that the nearring is in the system, let's ask | |
| 140 | some questions about it. A nearring is a nearfield if | |
| 141 | it has more than one element and its nonzero elements are | |
| 142 | a group with respect to multiplication. A textbook | |
| 143 | on nearfields is <a href="biblio.htm#Waehling:Fastkoerper"><[>Waehling:Fastkoerper</cite></a>]. They are interesting | |
| 144 | structures, closely connected to sharply 2-transitive permutation | |
| 145 | groups and fixedpointfree automorphism groups of groups. | |
| 146 | <p> | |
| 147 | <pre> | |
| 148 | gap> IsNearField( N ); | |
| 149 | false | |
| 150 | gap> IsIntegralNearRing( N ); | |
| 151 | false | |
| 152 | gap> IsNilpotentNearRing( N ); | |
| 153 | false | |
| 154 | </pre> | |
| 155 | <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>] is correct ... Well at least in this case.<code>;-))</code> | |
| 156 | <p> | |
| 157 | <p> | |
| 158 | <h2><a name="SECT003">2.3 Entering the nearring with less typing</a></h2> | |
| 159 | <p><p> | |
| 160 | Certainly, everybody has immediately seen, that this | |
| 161 | nearring is a transformation nearring on <code>GTW4_2</code> | |
| 162 | which is generated by the transformations | |
| 163 | <code>0</code> to <code>0</code>, <code>a</code> to <code>a</code>, <code>b</code> to <code>c</code>, <code>c</code> to <code>b</code>, and | |
| 164 | the identity transformation, so | |
| 165 | <p> | |
| 166 | <pre> | |
| 167 | gap> t := GroupGeneralMappingByImages( | |
| 168 | > G, G, AsSortedList(G), AsSortedList(G){[1,2,4,3]} ); | |
| 169 | [ (), (3,4), (1,2), (1,2)(3,4) ] -> [ (), (3,4), (1,2)(3,4), (1,2) ] | |
| 170 | gap> id := IdentityMapping( G ); | |
| 171 | IdentityMapping( 4/2 ) | |
| 172 | gap> T := TransformationNearRingByGenerators( G, [t,id] ); | |
| 173 | TransformationNearRingByGenerators( | |
| 174 | [ [ (), (3,4), (1,2), (1,2)(3,4) ] -> [ (), (3,4), (1,2)(3,4), (1,2) ], | |
| 175 | IdentityMapping( 4/2 ) ]) | |
| 176 | </pre> | |
| 177 | <p> | |
| 178 | Let's see what we've got: | |
| 179 | <p> | |
| 180 | <pre> | |
| 181 | gap> PrintTable(T); | |
| 182 | Let: | |
| 183 | n0 := <mapping: 4/2 -> 4/2 > | |
| 184 | n1 := <mapping: 4/2 -> 4/2 > | |
| 185 | n2 := <mapping: 4/2 -> 4/2 > | |
| 186 | n3 := <mapping: 4/2 -> 4/2 > | |
| 187 | ||
| 188 | + | n0 n1 n2 n3 | |
| 189 | -------------------- | |
| 190 | n0 | n0 n1 n2 n3 | |
| 191 | n1 | n1 n0 n3 n2 | |
| 192 | n2 | n2 n3 n0 n1 | |
| 193 | n3 | n3 n2 n1 n0 | |
| 194 | ||
| 195 | * | n0 n1 n2 n3 | |
| 196 | -------------------- | |
| 197 | n0 | n0 n0 n0 n0 | |
| 198 | n1 | n0 n0 n1 n1 | |
| 199 | n2 | n0 n1 n2 n3 | |
| 200 | n3 | n0 n1 n3 n2 | |
| 201 | </pre> | |
| 202 | <p> | |
| 203 | Obviously, we've got the correct nearring. | |
| 204 | Let's make for sure: | |
| 205 | <p> | |
| 206 | <pre> | |
| 207 | gap> IsIsomorphicNearRing( N, T ); | |
| 208 | true | |
| 209 | </pre> | |
| 210 | <p> | |
| 211 | However, <code>N</code> and <code>T</code> are certaily not equal: | |
| 212 | <p> | |
| 213 | <pre> | |
| 214 | gap> N = T; | |
| 215 | false | |
| 216 | </pre> | |
| 217 | <p> | |
| 218 | <p> | |
| 219 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 220 | <P> | |
| 221 | <address>SONATA-tutorial manual<br>October 2018 | |
| 222 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 3 The nearring library</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Previous</a>] [<a href ="CHAP004.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>3 The nearring library</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP003.htm#SECT001">An application of the nearring library</a> | |
| 8 | <li> <A HREF="CHAP003.htm#SECT002">Appendix K revisited</a> | |
| 9 | </ol><p> | |
| 10 | <p> | |
| 11 | There are many non-isomorphic nearrings, even of small order. | |
| 12 | All non-isomorphic nearrings of orders 2 to 15 and | |
| 13 | all non-isomorphic nearrings with identity up | |
| 14 | to order 31 with exception of those on | |
| 15 | the elementary abelian groups of orders | |
| 16 | 16 and 27 are collected in the SONATA | |
| 17 | nearring library. | |
| 18 | <p> | |
| 19 | <p> | |
| 20 | <h2><a name="SECT001">3.1 An application of the nearring library</a></h2> | |
| 21 | <p><p> | |
| 22 | The number of nearrings in the library is big. | |
| 23 | For example, try | |
| 24 | <p> | |
| 25 | <pre> | |
| 26 | gap> NumberLibraryNearRings( GTW12_3 ); | |
| 27 | 48137 | |
| 28 | </pre> | |
| 29 | <p> | |
| 30 | Try your favorite small groups with this | |
| 31 | function to get an impression of these | |
| 32 | numbers. | |
| 33 | <p> | |
| 34 | Of course, no one can know all these nearrings | |
| 35 | personally. Therefore, the main purpose | |
| 36 | of the nearring library is to filter out the | |
| 37 | nearrings of interest. | |
| 38 | <p> | |
| 39 | Consider for example the following | |
| 40 | <p> | |
| 41 | <strong>Problem:</strong> How many non-rings with identity of order 4 are | |
| 42 | there and what do they look like? If you cannot answer this | |
| 43 | question adhoc, stay tuned. | |
| 44 | <p> | |
| 45 | Let's start with the groups of order 4. Of course you know, | |
| 46 | there are 2 groups of order 4: <code>GTW4_1</code>, the cyclic group | |
| 47 | and <code>GTW4_2</code>, Klein's four group. | |
| 48 | <p> | |
| 49 | Let's go for <code>GTW4_1</code> first: | |
| 50 | <p> | |
| 51 | <pre> | |
| 52 | gap> NumberLibraryNearRingsWithOne( GTW4_1 ); | |
| 53 | 1 | |
| 54 | gap> Filtered( AllLibraryNearRingsWithOne( GTW4_1 ), | |
| 55 | > n -> not IsDistributiveNearRing( n ) ); | |
| 56 | [ ] | |
| 57 | </pre> | |
| 58 | <p> | |
| 59 | So, the only nearring with identity there is | |
| 60 | on <code>GTW4_1</code> is the ring. Well... you knew that before, | |
| 61 | didn't you? | |
| 62 | <p> | |
| 63 | Now for <code>GTW4_2</code>: | |
| 64 | <p> | |
| 65 | <pre> | |
| 66 | gap> NumberLibraryNearRingsWithOne( GTW4_2 ); | |
| 67 | 5 | |
| 68 | gap> Filtered( AllLibraryNearRingsWithOne( GTW4_2 ), | |
| 69 | > n -> not IsDistributiveNearRing( n ) ); | |
| 70 | [ LibraryNearRing(4/2, 12), LibraryNearRing(4/2, 22) ] | |
| 71 | </pre> | |
| 72 | <p> | |
| 73 | Here we go: | |
| 74 | <p> | |
| 75 | <pre> | |
| 76 | gap> PrintTable( LibraryNearRing( GTW4_2, 12 ) ); | |
| 77 | Let: | |
| 78 | n0 := (()) | |
| 79 | n1 := ((3,4)) | |
| 80 | n2 := ((1,2)) | |
| 81 | n3 := ((1,2)(3,4)) | |
| 82 | ||
| 83 | + | n0 n1 n2 n3 | |
| 84 | -------------------- | |
| 85 | n0 | n0 n1 n2 n3 | |
| 86 | n1 | n1 n0 n3 n2 | |
| 87 | n2 | n2 n3 n0 n1 | |
| 88 | n3 | n3 n2 n1 n0 | |
| 89 | ||
| 90 | * | n0 n1 n2 n3 | |
| 91 | -------------------- | |
| 92 | n0 | n0 n0 n0 n0 | |
| 93 | n1 | n0 n0 n1 n1 | |
| 94 | n2 | n0 n0 n2 n2 | |
| 95 | n3 | n0 n1 n2 n3 | |
| 96 | gap> PrintTable( LibraryNearRing( GTW4_2, 22 ) ); | |
| 97 | Let: | |
| 98 | n0 := (()) | |
| 99 | n1 := ((3,4)) | |
| 100 | n2 := ((1,2)) | |
| 101 | n3 := ((1,2)(3,4)) | |
| 102 | ||
| 103 | + | n0 n1 n2 n3 | |
| 104 | -------------------- | |
| 105 | n0 | n0 n1 n2 n3 | |
| 106 | n1 | n1 n0 n3 n2 | |
| 107 | n2 | n2 n3 n0 n1 | |
| 108 | n3 | n3 n2 n1 n0 | |
| 109 | ||
| 110 | * | n0 n1 n2 n3 | |
| 111 | -------------------- | |
| 112 | n0 | n0 n0 n2 n2 | |
| 113 | n1 | n0 n1 n2 n3 | |
| 114 | n2 | n0 n2 n2 n0 | |
| 115 | n3 | n0 n3 n2 n1 | |
| 116 | </pre> | |
| 117 | <p> | |
| 118 | <p> | |
| 119 | <h2><a name="SECT002">3.2 Appendix K revisited</a></h2> | |
| 120 | <p><p> | |
| 121 | An alternative to filtering the nearring library is to | |
| 122 | use a <code>for ... do ... od</code> construction. | |
| 123 | <p> | |
| 124 | We shall demonstrate this by recomputing the list | |
| 125 | of nearrings given in appendix K of <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>], | |
| 126 | i.e. a list of all nearrings on the dihedral group of order 8 | |
| 127 | (<code>GTW8_4</code>) which have an identity, are non-zerosymmetric or | |
| 128 | are integral. | |
| 129 | <p> | |
| 130 | First, we initialize the variable <code>nr_list</code> | |
| 131 | as the empty list: | |
| 132 | <p> | |
| 133 | <pre> | |
| 134 | gap> nr_list := [ ]; | |
| 135 | [ ] | |
| 136 | </pre> | |
| 137 | <p> | |
| 138 | Now, we write ourselves a <code>for</code> loop and add those nearrings | |
| 139 | we want: | |
| 140 | <p> | |
| 141 | <pre> | |
| 142 | gap> for i in [1..NumberLibraryNearRings( GTW8_4 )] do | |
| 143 | > n := LibraryNearRing( GTW8_4, i ); | |
| 144 | > if ( not IsZeroSymmetricNearRing( n ) or | |
| 145 | > IsIntegralNearRing( n ) or | |
| 146 | > Identity( n ) <> fail | |
| 147 | > ) then | |
| 148 | > Add( nr_list, n ); | |
| 149 | > fi; | |
| 150 | > od; | |
| 151 | gap> Length( nr_list ); | |
| 152 | 141 | |
| 153 | </pre> | |
| 154 | <p> | |
| 155 | How many boolean nearrings are amongst these? We call a nearring | |
| 156 | <strong>boolean</strong> if <i>x</i>*<i>x</i>=<i>x</i> for all <i>x</i> <font face="symbol">Î</font> <i>N</i>. | |
| 157 | <p> | |
| 158 | <pre> | |
| 159 | gap> Filtered( nr_list, IsBooleanNearRing ); | |
| 160 | [ LibraryNearRing(8/4, 1314), LibraryNearRing(8/4, 1380), | |
| 161 | LibraryNearRing(8/4, 1446), LibraryNearRing(8/4, 1447) ] | |
| 162 | </pre> | |
| 163 | <p> | |
| 164 | Which correspond to the numbers | |
| 165 | 140, 86, 99, and 141 in | |
| 166 | <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>], appendix K, accordingly. | |
| 167 | <p> | |
| 168 | For those who got interested in boolean nearrings: | |
| 169 | many results about them have been collected in | |
| 170 | <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>], 9.31. | |
| 171 | <p> | |
| 172 | <p> | |
| 173 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP002.htm">Previous</a>] [<a href ="CHAP004.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 174 | <P> | |
| 175 | <address>SONATA-tutorial manual<br>October 2018 | |
| 176 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 4 Nearrings of transformations on groups</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>4 Nearrings of transformations on groups</h1><p> | |
| 4 | <p> | |
| 5 | We are going to study transformations on the alternating group on four elements | |
| 6 | <i>A</i><sub>4</sub>. | |
| 7 | <p> | |
| 8 | <strong>The problem</strong>: Let <var>T</var> be the nearring of mappings from <i>A</i><sub>4</sub> to <i>A</i><sub>4</sub> | |
| 9 | generated by the single mapping <var>t</var> which maps (2,3,4) to (2,4,3), | |
| 10 | (2,4,3) to (1,2)(3,4), (1,2)(3,4) to (1,2,3), (1,2,3) back to (2,3,4) | |
| 11 | and all other elements of <i>A</i><sub>4</sub> to the neutral element (). Then, | |
| 12 | how many mappings are there in <var>T</var> that have (1,2,3) as a fixed point? | |
| 13 | If there are only a few we would be interested in a list of all of | |
| 14 | these. | |
| 15 | <p> | |
| 16 | <strong>The solution</strong>: <br> | |
| 17 | The first thing to do is create the nearring <var>T</var>. So we start with | |
| 18 | the group <i>A</i><sub>4</sub>, which can easily be constructed with the command | |
| 19 | <pre> | |
| 20 | gap> A4 := AlternatingGroup( 4 ); | |
| 21 | Alt( [ 1 .. 4 ] ) | |
| 22 | </pre> | |
| 23 | The result is an object which represents the group <i>A</i><sub>4</sub>. If we want | |
| 24 | to see its elements we have to ask <font face="Gill Sans,Helvetica,Arial">GAP</font> to make a list of elements | |
| 25 | out of the group. | |
| 26 | <pre> | |
| 27 | gap> AsSortedList( A4 ); | |
| 28 | [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), | |
| 29 | (1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ] | |
| 30 | </pre> | |
| 31 | Now we create the mapping <var>t</var>. We use the function | |
| 32 | <code>MappingByPositionList</code> to enter it. | |
| 33 | <pre> | |
| 34 | t := EndoMappingByPositionList( A4, [1,3,4,5,2,1,1,1,1,1,1,1] ); | |
| 35 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 36 | [ 1 .. 4 ] ) > | |
| 37 | </pre> | |
| 38 | For <code>Mappings</code> the usual operations <code>+</code> and | |
| 39 | <code>*</code> can be used to add and multiply them. | |
| 40 | <pre> | |
| 41 | gap> t+t; | |
| 42 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 43 | [ 1 .. 4 ] ) > | |
| 44 | gap> last * t; | |
| 45 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( | |
| 46 | [ 1 .. 4 ] ) > | |
| 47 | </pre> | |
| 48 | (Recall that <code>last</code> stands for the result of the last computation, in | |
| 49 | this case this is <code>t + t</code>). | |
| 50 | Now we can construct the nearring. We use the function | |
| 51 | <code>TransformationNearRingByGenerators</code> which asks for the group (<i>A</i><sub>4</sub>) | |
| 52 | and a list of generating elements (the list with <var>t</var> as the only entry) | |
| 53 | as arguments. | |
| 54 | <pre> | |
| 55 | gap> T := TransformationNearRingByGenerators( A4, [ t ] );; | |
| 56 | </pre> | |
| 57 | Nearrings, allthough generated by a single element can become rather | |
| 58 | big. Before we print out all elements we ask for the size of <var>T</var>. | |
| 59 | <pre> | |
| 60 | gap> Size( T ); | |
| 61 | 20736 | |
| 62 | </pre> | |
| 63 | It seems reasonable not to print all elements. <strong>Note</strong> that they are | |
| 64 | not even computed, yet. All we wanted to know was the size of <var>T</var> and | |
| 65 | this can be computed without generating all elements. But, yes, we | |
| 66 | could generate them with <code>AsList</code> or <code>AsSortedList</code>. At last we want | |
| 67 | to find out how many of these 20736 <code>GroupTransformations</code> have (1,2,3) | |
| 68 | as a fixed point. We filter them out, but we use a second semicolon at | |
| 69 | the end to suppress printing, because there might be a lot of them. | |
| 70 | Then we ask for the length of the resulting list <var>F</var> of mappings. | |
| 71 | <pre> | |
| 72 | gap> F := Filtered( T, tfm -> Image( tfm, (1,2,3) ) = (1,2,3) );; | |
| 73 | gap> Length( F ); | |
| 74 | 1728 | |
| 75 | </pre> | |
| 76 | It seems not to be worth printing the whole list. But we could for | |
| 77 | example choose a random transformation from this list <var>F</var> for testing | |
| 78 | purposes. | |
| 79 | <pre> | |
| 80 | gap> Random( F );; | |
| 81 | </pre> | |
| 82 | There are of course other properties of the nearring <var>T</var> | |
| 83 | which might be interesting. It is clear that a nearring which is | |
| 84 | generated by a single element is not necessarily abelian. <var>T</var> is a | |
| 85 | counterexample. As for finding counterexamples, SONATA can be used | |
| 86 | as a research tool. | |
| 87 | <pre> | |
| 88 | gap> IsCommutative( T ); | |
| 89 | false | |
| 90 | </pre> | |
| 91 | Finally, we try to disprove the conjecture that every transformation | |
| 92 | nearring on an abelian group that is generated by a single element | |
| 93 | must be commutative. | |
| 94 | <pre> | |
| 95 | gap> g := CyclicGroup(2);; | |
| 96 | gap> m := MapNearRing(g);; | |
| 97 | gap> Filtered( m, n -> not( IsCommutative( | |
| 98 | > TransformationNearRingByGenerators( g, [n] ) ) ) ); | |
| 99 | gap> [ <mapping: Group( [ f1 ] ) -> Group( [ f1 ] ) >, | |
| 100 | <mapping: Group( [ f1 ] ) -> Group( [ f1 ] ) > ] | |
| 101 | gap> GraphOfMapping(last[1]); | |
| 102 | [ [ <identity> of ..., f1 ], [ f1, <identity> of ... ] ] | |
| 103 | </pre> | |
| 104 | <p> | |
| 105 | <p> | |
| 106 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 107 | <P> | |
| 108 | <address>SONATA-tutorial manual<br>October 2018 | |
| 109 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 5 Some interesting nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP004.htm">Previous</a>] [<a href ="CHAP006.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>5 Some interesting nearrings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP005.htm#SECT001">Nearrings generated by endomorphisms on a group</a> | |
| 8 | <li> <A HREF="CHAP005.htm#SECT002">More information than just the size</a> | |
| 9 | <li> <A HREF="CHAP005.htm#SECT003">Centralizer nearrings</a> | |
| 10 | <li> <A HREF="CHAP005.htm#SECT004">Finding affine complete groups</a> | |
| 11 | </ol><p> | |
| 12 | <p> | |
| 13 | One motivation for creating SONATA was to study | |
| 14 | particular near-rings associated with a given | |
| 15 | group <i>G</i>: the <strong>inner automorphism nearring</strong> | |
| 16 | <i>I</i>(<i>G</i>), the <strong>automorphism nearring</strong> <i>A</i>(<i>G</i>), and | |
| 17 | the <strong>endomorphism nearring</strong> <i>E</i>(<i>G</i>). | |
| 18 | The nearring <i>I</i>(<i>G</i>) is the smallest subnearring of the | |
| 19 | nearring <i>M</i>(<i>G</i>) of all mappings from <i>G</i> into <i>G</i> that | |
| 20 | contains all inner automorphisms; similarly <i>A</i>(<i>G</i>) and <i>E</i>(<i>G</i>) | |
| 21 | are defined. <a href="biblio.htm#meldrum85:NATLWG"><[>meldrum85:NATLWG</cite></a>] contains | |
| 22 | a lot of information on these near-rings. | |
| 23 | <p> | |
| 24 | <p> | |
| 25 | <h2><a name="SECT001">5.1 Nearrings generated by endomorphisms on a group</a></h2> | |
| 26 | <p><p> | |
| 27 | Let us compute the nearring <i>I</i>(<i>A</i><sub>4</sub>), which is the nearring of all | |
| 28 | zero-symmetric polynomial functions on the group <i>A</i><sub>4</sub>. | |
| 29 | <pre> | |
| 30 | gap> I := InnerAutomorphismNearRing ( AlternatingGroup ( 4 ) ); | |
| 31 | InnerAutomorphismNearRing( Alt( [ 1 .. 4 ] ) ) | |
| 32 | gap> Size (I); | |
| 33 | 3072 | |
| 34 | </pre> | |
| 35 | <p> | |
| 36 | For a polynomial function, we can ask for a polynomial that induces it. | |
| 37 | <p> | |
| 38 | <pre> | |
| 39 | gap> p := Random( I ); | |
| 40 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( [ 1 .. 4 ] ) > | |
| 41 | gap> PrintAsTerm( p ); | |
| 42 | - g1 + g2 - x - g2 + g1 + g2 + g1 - x + g2 - x + 2 * g1 - | |
| 43 | 3 * x - g1 + x + g2 - x - g2 + g1 + x - g1 + x - g1 + x + | |
| 44 | g1 + x - g2 - x + g2 - g1 - x + g1 + x | |
| 45 | gap> GeneratorsOfGroup( AlternatingGroup( 4 ) ); | |
| 46 | [ (1,2,3), (2,3,4) ] | |
| 47 | </pre> | |
| 48 | <p> | |
| 49 | We get a polynomial (not necessarily the shortest possible polynomial) that induces | |
| 50 | the polynomial function. The expressions <code>g1</code> and <code>g2</code> stand for the first and second | |
| 51 | generator of the group respectively. | |
| 52 | <p> | |
| 53 | Now we compute the nearring that is additively generated by the automorphisms | |
| 54 | of the dihedral group of order 8. This nearring is usually called | |
| 55 | <i>A</i> (<i>D</i><sub>8</sub>). | |
| 56 | <pre> | |
| 57 | gap> A := AutomorphismNearRing ( DihedralGroup ( 8 ) ); | |
| 58 | AutomorphismNearRing( <pc group of size 8 with 3 generators> ) | |
| 59 | gap> Size (A); | |
| 60 | 32 | |
| 61 | </pre> | |
| 62 | <p> | |
| 63 | Much attention has been devoted to the nearring <i>E</i> (<i>S</i><sub>4</sub>), which | |
| 64 | is the nearring additively generated by the endomorphisms on the | |
| 65 | symmetric group on four letters. | |
| 66 | <pre> | |
| 67 | gap> EndS4 := EndomorphismNearRing ( SymmetricGroup ( 4 ) ); | |
| 68 | EndomorphismNearRing( Sym( [ 1 .. 4 ] ) ) | |
| 69 | gap> Size ( EndS4 ); | |
| 70 | 927712935936 | |
| 71 | gap> F1 := last;; | |
| 72 | gap> Collected ( Factors( F1 )); | |
| 73 | [ [ 2, 35 ], [ 3, 3 ] ] | |
| 74 | </pre> | |
| 75 | In the last example, we have computed the size | |
| 76 | of <i>E</i> (<i>S</i><sub>4</sub>) as 2<sup>35</sup> ·3<sup>3</sup>. | |
| 77 | <p> | |
| 78 | We have also included some less popular examples of nearrings. | |
| 79 | One of those is the nearring <i>H</i> (<i>G</i>, <i>U</i>). This is the nearring | |
| 80 | that is generated by all endomorphisms on <i>G</i> whose range lies in | |
| 81 | the subgroup <i>U</i> of <i>G</i>. | |
| 82 | We do an example on the group 16/8 in the classification of | |
| 83 | Thomas and Wood. It is a subdirectly irreducible group of order 16, | |
| 84 | and the factor modulo the monolith is isomorphic to the elementary abelian group | |
| 85 | of order 8. | |
| 86 | <pre> | |
| 87 | gap> G := GTW16_8; | |
| 88 | 16/8 | |
| 89 | gap> U := First ( NormalSubgroups( G ), N -> Size(N) = 2 ); | |
| 90 | Group([ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) | |
| 91 | gap> HGU := RestrictedEndomorphismNearRing (G, U); | |
| 92 | RestrictedEndomorphismNearRing( 16/8, Group( | |
| 93 | [ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) ) | |
| 94 | gap> Size (HGU); | |
| 95 | 8 | |
| 96 | </pre> | |
| 97 | It is interesting to compare this nearring to the nearring of | |
| 98 | all functions <i>e</i> in the endomorphism nearring <i>E</i> (<i>G</i>) with the | |
| 99 | property <i>e</i> (<i>G</i>) <font face="symbol">Í</font> <i>U</i>. | |
| 100 | <pre> | |
| 101 | gap> EofG := EndomorphismNearRing ( G ); | |
| 102 | EndomorphismNearRing( 16/8 ) | |
| 103 | gap> EGU := NoetherianQuotient ( EofG, U, G ); | |
| 104 | NoetherianQuotient( Group( | |
| 105 | [ ( 1, 5)( 2,10)( 3,11)( 4,12)( 6,15)( 7,16)( 8, 9)(13,14) ]) ,16/8 ) | |
| 106 | gap> Size ( EGU ); | |
| 107 | 128 | |
| 108 | </pre> | |
| 109 | If <i>N</i> is a transformation nearring on <i>G</i>, and <i>U</i>, <i>V</i> are subsets of <i>G</i> then | |
| 110 | <code>NoetherianQuotient (N,U,V)</code> returns the collection of all mappings | |
| 111 | <i>f</i> <font face="symbol">Î</font> <i>N</i> such that <i>f</i>(<i>V</i>) <font face="symbol">Í</font> <i>U</i>. | |
| 112 | <p> | |
| 113 | <p> | |
| 114 | <h2><a name="SECT002">5.2 More information than just the size</a></h2> | |
| 115 | <p><p> | |
| 116 | In this section, we use SONATA to produce some interesting information | |
| 117 | about the nearring <i>I</i>(<i>S</i><sub>3</sub>), which is the nearring of all zero-symmetric polynomial | |
| 118 | functions on the group <i>S</i><sub>3</sub>. | |
| 119 | <p> | |
| 120 | <pre> | |
| 121 | gap> G := SymmetricGroup ( 3 ); | |
| 122 | Sym( [ 1 .. 3 ] ) | |
| 123 | gap> I := InnerAutomorphismNearRing ( G ); | |
| 124 | InnerAutomorphismNearRing( Sym( [ 1 .. 3 ] ) ) | |
| 125 | gap> Size( I ); | |
| 126 | 54 | |
| 127 | </pre> | |
| 128 | <p> | |
| 129 | Now we would like to see how many of these 54 functions are idempotent. | |
| 130 | First a complicated version. | |
| 131 | <pre> | |
| 132 | gap> Filtered ( I, | |
| 133 | > t -> ForAll( G, g -> Image(t, g) = Image(t, Image(t, g)) ) );; | |
| 134 | gap> Length( last ); | |
| 135 | 18 | |
| 136 | </pre> | |
| 137 | Now a simpler version. | |
| 138 | <pre> | |
| 139 | gap> Filtered ( I, i -> i^2 = i );; | |
| 140 | gap> Length( last ); | |
| 141 | 18 | |
| 142 | </pre> | |
| 143 | <p> | |
| 144 | <p> | |
| 145 | <h2><a name="SECT003">5.3 Centralizer nearrings</a></h2> | |
| 146 | <p><p> | |
| 147 | Let <font face="symbol">F</font> be a subset of the endomorphisms of a group <i>G</i>. | |
| 148 | Then we define <i>M</i><sub><font face="symbol">F</font></sub> (<i>G</i>) as the set of all | |
| 149 | mappings <i>m</i> : <i>G</i> <font face="symbol">®</font> <i>G</i> that satisfy <i>m</i> <font face="symbol">°</font><font face="symbol">j</font> = <font face="symbol">j</font><font face="symbol">°</font><i>m</i> for all <font face="symbol">j</font> <font face="symbol">Î</font> <font face="symbol">F</font>. | |
| 150 | This set is closed under addition and composition of | |
| 151 | mappings, and hence a subnearring of <i>M</i>(<i>G</i>). | |
| 152 | The set <i>M</i><sub><font face="symbol">F</font></sub> (<i>G</i>) is called the centralizer nearring | |
| 153 | of <i>G</i> determined by <font face="symbol">F</font>. It need not necessarily be | |
| 154 | zero-symmetric. | |
| 155 | <p> | |
| 156 | In the following examples, we compute the centralizer nearring | |
| 157 | <i>M</i><sub><i>End</i> (<i>S</i><sub>3</sub>)</sub> (<i>S</i><sub>3</sub>). | |
| 158 | <pre> | |
| 159 | gap> G := SymmetricGroup( 3 ); | |
| 160 | Sym( [ 1 .. 3 ] ) | |
| 161 | gap> endos := Endomorphisms( G ); | |
| 162 | [ [ (1,2,3), (1,2) ] -> [ (), () ], [ (1,2,3), (1,2) ] -> [ (), (1,3) ], | |
| 163 | [ (1,2,3), (1,2) ] -> [ (), (2,3) ], [ (1,2,3), (1,2) ] -> [ (), (1,2) ], | |
| 164 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,3) ], | |
| 165 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,2) ], | |
| 166 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,3) ], | |
| 167 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (2,3) ], | |
| 168 | [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,2) ], | |
| 169 | [ (1,2,3), (1,2) ] -> [ (1,3,2), (2,3) ] ] | |
| 170 | gap> C := CentralizerNearRing( G, endos ); | |
| 171 | CentralizerNearRing( Sym( [ 1 .. 3 ] ), ... ) | |
| 172 | gap> Size ( C ); | |
| 173 | 6 | |
| 174 | </pre> | |
| 175 | <p> | |
| 176 | An <strong>ideal</strong> of a nearring (<i>N</i>,+,*) is a subset <i>I</i> such that | |
| 177 | <i>I</i> is a normal subgroup of (<i>N</i>,+), and | |
| 178 | for all <i>i</i> <font face="symbol">Î</font> <i>I</i>, <i>n</i>,<i>m</i> <font face="symbol">Î</font> <i>N</i>, we have | |
| 179 | (<i>m</i>+<i>i</i>)*<i>n</i> <font face="symbol">-</font> <i>m</i>*<i>n</i> <font face="symbol">Î</font> <i>I</i> and <i>n</i>*<i>i</i> <font face="symbol">Î</font> <i>I</i>. Ideals are in | |
| 180 | one-to-one correspondence to the congruence relations | |
| 181 | on (<i>N</i>,+,*). | |
| 182 | <p> | |
| 183 | Do you think that this nearring is simple? Alan Cannon does not think so, | |
| 184 | and, in fact, SONATA tells us: | |
| 185 | <pre> | |
| 186 | gap> I := NearRingIdeals( C ); | |
| 187 | [ < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 188 | < nearring ideal > ] | |
| 189 | gap> List( I, Size ); | |
| 190 | [ 1, 2, 3, 6 ] | |
| 191 | </pre> | |
| 192 | So, we have ideals of size 1,2,3 and 6. | |
| 193 | <p> | |
| 194 | <p> | |
| 195 | <h2><a name="SECT004">5.4 Finding affine complete groups</a></h2> | |
| 196 | <p><p> | |
| 197 | We shall now construct all compatible (= congruence preserving) functions | |
| 198 | on the group 16/6 (Thomas-Wood-notation); this is the 6<sup><i>th</i></sup> group | |
| 199 | of order 16 in <a href="biblio.htm#thomaswood80:GT"><[>thomaswood80:GT</cite></a>]. | |
| 200 | It is the direct | |
| 201 | product of <i>D</i><sub>8</sub> and <i>C</i><sub>2</sub>. Let <i>G</i> be this group. We first | |
| 202 | construct the nearring <i>P</i>(<i>G</i>) of all polynomial functions. | |
| 203 | Then we construct all those functions that can be interpolated | |
| 204 | at every subset of <i>G</i> with at most two elements by a function in | |
| 205 | <i>P</i>(<i>G</i>) by using the function <code>LocalInterpolationNearRing</code>: | |
| 206 | these are the compatible functions on <i>G</i> (see <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>)]. | |
| 207 | <pre> | |
| 208 | gap> P := PolynomialNearRing( GTW16_6 ); | |
| 209 | PolynomialNearRing( 16/6 ) | |
| 210 | gap> Size( P ); | |
| 211 | 256 | |
| 212 | gap> C := LocalInterpolationNearRing(P, 2); | |
| 213 | LocalInterpolationNearRing( PolynomialNearRing( 16/6 ), 2 ) | |
| 214 | gap> Size (C); | |
| 215 | 256 | |
| 216 | </pre> | |
| 217 | Hence the group 16/6 is 1-affine complete. A much faster algorithm for | |
| 218 | computing the nearring of compatible functions can be used. | |
| 219 | <pre> | |
| 220 | gap> C := CompatibleFunctionNearRing( GTW16_6 ); | |
| 221 | < transformation nearring with 7 generators > | |
| 222 | gap> Size(C); | |
| 223 | 256; | |
| 224 | </pre> | |
| 225 | Finally, the fastest way to decide 1-affine completeness is to use the function | |
| 226 | <code>Is1AffineComplete</code>. | |
| 227 | <pre> | |
| 228 | gap> Is1AffineComplete( GTW16_6 ); | |
| 229 | true | |
| 230 | </pre> | |
| 231 | <p> | |
| 232 | When studying polynomial functions on direct products of groups, it is | |
| 233 | important to know the smallest positive number <i>l</i> such | |
| 234 | that the zero-function can be expressed by a term | |
| 235 | <i>a</i><sub>1</sub> + <i>e</i><sub>1</sub>·<i>x</i> + <i>a</i><sub>2</sub> + <font face="symbol">¼</font>+ <i>e</i><sub><i>n</i></sub>·<i>x</i> + <i>a</i><sub><i>n</i>+1</sub> with | |
| 236 | <font face="symbol">å</font><i>e</i><sub><i>i</i></sub> = <i>l</i>. | |
| 237 | This <i>l</i> has been called the <strong>length</strong> of the group | |
| 238 | by S.D.Scott. | |
| 239 | <p> | |
| 240 | <pre> | |
| 241 | gap> ScottLength( SymmetricGroup( 3 ) ); | |
| 242 | 2 | |
| 243 | </pre> | |
| 244 | <p> | |
| 245 | <p> | |
| 246 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP004.htm">Previous</a>] [<a href ="CHAP006.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 247 | <P> | |
| 248 | <address>SONATA-tutorial manual<br>October 2018 | |
| 249 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 6 Ideals, factors, and direct products of nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP005.htm">Previous</a>] [<a href ="CHAP007.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>6 Ideals, factors, and direct products of nearrings</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP006.htm#SECT001">Direct products</a> | |
| 8 | <li> <A HREF="CHAP006.htm#SECT002">Ideals and factors</a> | |
| 9 | </ol><p> | |
| 10 | <p> | |
| 11 | An <strong>ideal</strong> of a nearring (<i>N</i>,+,*) is a subset <i>I</i> such that | |
| 12 | <i>I</i> is a normal subgroup of (<i>N</i>,+), and | |
| 13 | for all <i>i</i> <font face="symbol">Î</font> <i>I</i>, <i>n</i>,<i>m</i> <font face="symbol">Î</font> <i>N</i>, we have | |
| 14 | (<i>m</i>+<i>i</i>)*<i>n</i> <font face="symbol">-</font> <i>m</i>*<i>n</i> <font face="symbol">Î</font> <i>I</i> and <i>n</i>*<i>i</i> <font face="symbol">Î</font> <i>I</i>. Ideals are in | |
| 15 | one-to-one correspondence to the congruence relations | |
| 16 | on (<i>N</i>,+,*). | |
| 17 | <p> | |
| 18 | A <strong>right ideal</strong> of a nearring (<i>N</i>,+,*) is a subset <i>I</i> such that | |
| 19 | <i>I</i> is a normal subgroup of (<i>N</i>,+), and | |
| 20 | for all <i>i</i> <font face="symbol">Î</font> <i>I</i>, <i>n</i>,<i>m</i> <font face="symbol">Î</font> <i>N</i>, we have | |
| 21 | (<i>m</i>+<i>i</i>)*<i>n</i> <font face="symbol">-</font> <i>m</i>*<i>n</i> <font face="symbol">Î</font> <i>I</i>. Right ideals are in | |
| 22 | one-to-one correspondence to the congruence relations | |
| 23 | on (<i>N</i>,+, { <font face="symbol">l</font><sub><i>m</i></sub> <font face="symbol">|</font> <i>m</i> <font face="symbol">Î</font> <i>M</i> } ), where | |
| 24 | <font face="symbol">l</font><sub><i>m</i></sub> (<i>n</i>) : = <i>n</i>*<i>m</i>. Hence, right ideals | |
| 25 | describe the congruences of the <i>N</i>-group | |
| 26 | <i>N</i><sub><i>N</i></sub>. | |
| 27 | <p> | |
| 28 | A <strong>left ideal</strong> of a nearring (<i>N</i>,+,*) is a subset <i>I</i> such that | |
| 29 | <i>I</i> is a normal subgroup of (<i>N</i>,+), and | |
| 30 | for all <i>i</i> <font face="symbol">Î</font> <i>I</i>, <i>n</i> <font face="symbol">Î</font> <i>N</i>, we have | |
| 31 | <i>n</i>*<i>i</i> <font face="symbol">Î</font> <i>I</i>. | |
| 32 | <p> | |
| 33 | <p> | |
| 34 | <h2><a name="SECT001">6.1 Direct products</a></h2> | |
| 35 | <p><p> | |
| 36 | For all sorts of nearrings direct products <i>A</i> ×<i>B</i> can be constructed. The | |
| 37 | result is again a nearring. In the case that both <var>A</var> and <var>B</var> | |
| 38 | are <code>TransformationNearRings</code>, the result will be a <code>TransformationNearRing</code> | |
| 39 | acting on the direct product of the groups <var>A</var> and <var>B</var> act on. In any other | |
| 40 | case the result is an <code>ExplicitMultiplicationNearRing</code>, even if one of the | |
| 41 | factors is a <code>TransformationNearRing</code>. In any case, the elements of a direct | |
| 42 | product are <strong>not</strong> pairs or tuples. | |
| 43 | <pre> | |
| 44 | gap> A := LibraryNearRing( GTW8_2, 12 ); | |
| 45 | LibraryNearRing(8/2, 12) | |
| 46 | gap> B := LibraryNearRing( GTW12_4, 13 ); | |
| 47 | LibraryNearRing(12/4, 13) | |
| 48 | gap> D := DirectProductNearRing( A, B ); | |
| 49 | DirectProductNearRing( LibraryNearRing(8/2, 12), | |
| 50 | LibraryNearRing(12/4, 13) ) | |
| 51 | gap> SetName( D, "A x B" ); | |
| 52 | gap> D; | |
| 53 | A x B | |
| 54 | </pre> | |
| 55 | In this case the result is an <code>ExplicitMultiplicationNearRing</code>. | |
| 56 | It is a good idea to give a shorter name to the nearring <var>D</var>, because | |
| 57 | we will investigate one of its ideals in the next section. | |
| 58 | <p> | |
| 59 | <p> | |
| 60 | <h2><a name="SECT002">6.2 Ideals and factors</a></h2> | |
| 61 | <p><p> | |
| 62 | We go on with the last example of the previous section and try to | |
| 63 | compute a left ideal which is generated by two elements, namely the | |
| 64 | second and the twenty-fifth in the sorted list of elements. The <font face="Gill Sans,Helvetica,Arial">GAP</font> | |
| 65 | function <code>list{[ poss ]}</code> constructs a list of those elements | |
| 66 | of the list <code>list</code> the position in the list <code>list</code> of which is | |
| 67 | in the list <code>poss</code>. For short, <code>elms{[2,25]}</code> is a list which | |
| 68 | contains the second and the twenty-fifth element of the list <code>elms</code>. | |
| 69 | <pre> | |
| 70 | gap> elms := AsSortedList( D );; | |
| 71 | gap> gens := elms{[2,25]}; | |
| 72 | [ (( 8, 9,10)), ((3,5)(4,6)) ] | |
| 73 | gap> L := NearRingLeftIdealByGenerators( D, gens ); | |
| 74 | < nearring left ideal > | |
| 75 | </pre> | |
| 76 | Now we can start investigating <var>I</var>. We can compute its size and test | |
| 77 | if it is an ideal. | |
| 78 | <pre> | |
| 79 | gap> Size( L ); | |
| 80 | 24 | |
| 81 | gap> IsNearRingRightIdeal( L ); | |
| 82 | true | |
| 83 | gap> L; | |
| 84 | < nearring ideal of size 24 > | |
| 85 | </pre> | |
| 86 | So <var>L</var> is a two-sided ideal with 24 elements. Now we are getting | |
| 87 | interested in <var>L</var>. Is it a maximal ideal, what is the factor <var>D/L</var>? | |
| 88 | <pre> | |
| 89 | gap> IsMaximalNearRingIdeal( L ); | |
| 90 | false | |
| 91 | gap> F := D/L; | |
| 92 | FactorNearRing( A x B, < nearring ideal of size 24 > ) | |
| 93 | gap> PrintTable( F, "am" ); | |
| 94 | ||
| 95 | + | n0 n1 n2 n3 | |
| 96 | -------------------- | |
| 97 | n0 | n0 n1 n2 n3 | |
| 98 | n1 | n1 n0 n3 n2 | |
| 99 | n2 | n2 n3 n0 n1 | |
| 100 | n3 | n3 n2 n1 n0 | |
| 101 | ||
| 102 | * | n0 n1 n2 n3 | |
| 103 | -------------------- | |
| 104 | n0 | n0 n0 n0 n0 | |
| 105 | n1 | n0 n0 n0 n0 | |
| 106 | n2 | n0 n0 n0 n0 | |
| 107 | n3 | n0 n0 n0 n0 | |
| 108 | </pre> | |
| 109 | Here, we use <code>PrintTable</code> with a second argument, because we do | |
| 110 | not want to see all the information. Here <code>a</code> stands for addition and <code>m</code> | |
| 111 | stands for multiplication table. For more options see the reference | |
| 112 | manual. Obviously, <var>F</var> is a constant nearring on a group of order 4. | |
| 113 | The additive group of the nearring is <b>Z</b><sub>2</sub> ×<b>Z</b><sub>2</sub>. To make this | |
| 114 | fact more obvious, we choose other names (symbols) for the elements | |
| 115 | of the nearring and print the addition table again. | |
| 116 | <pre> | |
| 117 | gap> IsElementaryAbelian( GroupReduct( F ) ); | |
| 118 | true | |
| 119 | gap> # this would also convince us | |
| 120 | gap> IsCyclic( GroupReduct( F ) ); | |
| 121 | false | |
| 122 | gap> SetSymbols( F, ["(0,0)","(0,1)","(1,0)","(1,1)"] ); | |
| 123 | gap> PrintTable( F, "m" ); | |
| 124 | ||
| 125 | * | (0,0) (0,1) (1,0) (1,1) | |
| 126 | ----------------------------------- | |
| 127 | (0,0) | (0,0) (0,0) (0,0) (0,0) | |
| 128 | (0,1) | (0,0) (0,0) (0,0) (0,0) | |
| 129 | (1,0) | (0,0) (0,0) (0,0) (0,0) | |
| 130 | (1,1) | (0,0) (0,0) (0,0) (0,0) | |
| 131 | </pre> | |
| 132 | So <var>F</var> is the zero-ring on <b>Z</b><sub>2</sub> ×<b>Z</b><sub>2</sub>, which is not simple, | |
| 133 | but we knew that before. | |
| 134 | <p> | |
| 135 | Of course all this operations can be applied to all nearrings. | |
| 136 | <p> | |
| 137 | <p> | |
| 138 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP005.htm">Previous</a>] [<a href ="CHAP007.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 139 | <P> | |
| 140 | <address>SONATA-tutorial manual<br>October 2018 | |
| 141 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 7 Planar nearrings</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP006.htm">Previous</a>] [<a href ="CHAP008.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>7 Planar nearrings</h1><p> | |
| 4 | <p> | |
| 5 | We recall the definition of planar nearrings and basic results | |
| 6 | (see <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>)]. | |
| 7 | Let (<i>N</i>,+,·) be a left nearring. For <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i> we define <i>a</i> <font face="symbol">º</font> <i>b</i> | |
| 8 | iff <i>a</i>·<i>n</i> = <i>b</i>·<i>n</i> for all <i>n</i> <font face="symbol">Î</font> <i>N</i>. If <i>a</i> <font face="symbol">º</font> <i>b</i>, then <i>a</i> and <i>b</i> | |
| 9 | are called <strong>equivalent multipliers</strong>. | |
| 10 | A nearring <i>N</i> is called <strong>planar</strong> if <font face="symbol">|</font> <i>N</i>/<sub> <font face="symbol">º</font> </sub> <font face="symbol">|</font> <font face="symbol">³</font> 3 and if | |
| 11 | for any two non-equivalent multipliers <i>a</i> and <i>b</i> in <i>N</i>, for any <i>c</i> <font face="symbol">Î</font> <i>N</i>, | |
| 12 | the equation <i>a</i>·<i>x</i> = <i>b</i>·<i>x</i> + <i>c</i> has a unique solution. | |
| 13 | <p> | |
| 14 | A <strong>Ferrero pair</strong> is a pair of finite groups (<i>N</i>,<font face="symbol">F</font>) such that <font face="symbol">F</font> | |
| 15 | is a fixed-point-free automorphism group of (<i>N</i>,+). | |
| 16 | <p> | |
| 17 | Starting with a Ferrero pair (<i>N</i>,<font face="symbol">F</font>) we can construct a planar nearring | |
| 18 | in the following way: | |
| 19 | Select representatives, say <i>e</i><sub>1</sub>,<font face="symbol">¼</font>,<i>e</i><sub><i>t</i></sub>, for some or all of the | |
| 20 | non-trivial orbits of <i>N</i> under <font face="symbol">F</font>. | |
| 21 | Let <i>C</i> = <font face="symbol">F</font>(<i>e</i><sub>1</sub>)<font face="symbol">È</font><font face="symbol">¼</font><font face="symbol">È</font><font face="symbol">F</font>(<i>e</i><sub><i>t</i></sub>). | |
| 22 | For each <i>x</i> <font face="symbol">Î</font> <i>N</i> we define <i>a</i>·<i>x</i> = 0 for <i>a</i> <font face="symbol">Î</font> <i>N</i>\<i>C</i>, and | |
| 23 | <i>a</i>·<i>x</i>=<font face="symbol">f</font><sub><i>a</i></sub>(<i>x</i>) for <i>a</i> <font face="symbol">Î</font> <font face="symbol">F</font>(<i>e</i><sub><i>i</i></sub>) <font face="symbol">Ì</font> <i>C</i> and <font face="symbol">f</font><sub><i>a</i></sub>(<i>e</i><sub><i>i</i></sub>)=<i>a</i>. | |
| 24 | Then (<i>N</i>,+,·) is a (left) planar nearring with <font face="symbol">|</font><i>N</i>/<sub> <font face="symbol">º</font> </sub><font face="symbol">|</font> = <font face="symbol">|</font><font face="symbol">F</font><font face="symbol">|</font>+1. | |
| 25 | <p> | |
| 26 | Every finite planar nearring can be constructed from some Ferrero pair | |
| 27 | together with a set of orbit representatives in this way. | |
| 28 | <p> | |
| 29 | <strong>The problem:</strong> Find a planar nearring with 25 elements and 9 pairwise | |
| 30 | non-equivalent multipliers. | |
| 31 | <p> | |
| 32 | <strong>The solution:</strong> We follow the Ferrero method described above for defining a | |
| 33 | nearring multiplication on an additive group. | |
| 34 | First we have to find a fixed-point-free (fpf) automorphism group of | |
| 35 | order 8 on a group of order 25. | |
| 36 | <p> | |
| 37 | We start with the cyclic group of order 25: | |
| 38 | First of all we ask for the existence of an fpf automorphism group | |
| 39 | on <code>CyclicGroup(25)</code> by computing an upper bound for its order. | |
| 40 | <p> | |
| 41 | <pre> | |
| 42 | gap> FpfAutomorphismGroupsMaxSize( CyclicGroup(25) ); | |
| 43 | [ 4, 1 ] | |
| 44 | </pre> | |
| 45 | <p> | |
| 46 | This function returns a list with two integers, 4 and 1. | |
| 47 | The first number is an upper bound for the size of an fpf automorphism group; | |
| 48 | if there is a metacyclic fpf automorphism group, then it has a cyclic normal | |
| 49 | subgroup of index dividing the second number. These bounds are not sharp. | |
| 50 | If the upper bound for the size of an fpf automorphism group on some group | |
| 51 | is 1, we know that there is no nontrivial fpf automorphism group, no | |
| 52 | Ferrero pair, and no planar nearring on this group at all. | |
| 53 | <p> | |
| 54 | Here, SONATA does not exclude the possibility that the cyclic group of | |
| 55 | order 25 has an fpf automorphism group of order 4. | |
| 56 | However, we can be sure that all fpf automorphism groups are cyclic and that | |
| 57 | none of them has size 8. | |
| 58 | <p> | |
| 59 | Thus we have to consider the elementary abelian group of order 25 instead. | |
| 60 | <p> | |
| 61 | <pre> | |
| 62 | gap> FpfAutomorphismGroupsMaxSize( ElementaryAbelianGroup(25) ); | |
| 63 | [ 24, 2 ] | |
| 64 | </pre> | |
| 65 | <p> | |
| 66 | There might even exist an fpf automorphism group of order 24. (In fact | |
| 67 | there is more than one. The reference manual explains how to obtain all | |
| 68 | nearfields of size 25.) | |
| 69 | For our example, we could compute either a cyclic automorphism group or one | |
| 70 | isomorphic to the quaternion group with 8 elements. Let's try the latter. | |
| 71 | <p> | |
| 72 | <pre> | |
| 73 | gap> aux := FpfAutomorphismGroupsMetacyclic( [5,5], 4, -1 ); | |
| 74 | [ [ [ [ f1, f2 ] -> [ f1^2, f2^3 ], [ f1, f2 ] -> [ f2^4, f1 ] ] ], | |
| 75 | <pc group of size 25 with 2 generators> ] | |
| 76 | </pre> | |
| 77 | <p> | |
| 78 | Here, the function <code>FpfAutomorphismGroupsMetacyclic</code> determines the metacyclic | |
| 79 | fpf automorphism groups on <code>AbelianGroup([5,5])</code> with generators <i>p</i>,<i>q</i> | |
| 80 | satisfying <i>p</i><sup>4</sup> = 1, <i>p</i><sup><i>q</i></sup> = <i>p</i><sup><font face="symbol">-</font>1</sup>, and <i>q</i><sup>2</sup> = <i>p</i><sup>2</sup>. For each conjugacy class | |
| 81 | of such groups one representative is given. Conjugacy is determined within the | |
| 82 | whole automorphism group of <code>AbelianGroup([5,5])</code>. | |
| 83 | The actual output of the function is a list with 2 elements. | |
| 84 | The first is not the list of fpf groups up to conjugacy but the list of | |
| 85 | automorphisms <i>p</i>,<i>q</i> generating those groups. | |
| 86 | The second element is simply the group <code>AbelianGroup([5,5])</code>, on which the | |
| 87 | automorphisms act. | |
| 88 | <p> | |
| 89 | Since there is only one pair of generators <i>p</i>,<i>q</i>, all fpf automorphism groups | |
| 90 | isomorphic to the quaternion group are conjugate. Now, we have our Ferrero | |
| 91 | pair (<i>G</i>, <font face="symbol">F</font>). | |
| 92 | <p> | |
| 93 | <pre> | |
| 94 | gap> phi := Group( aux[1][1] ); | |
| 95 | <group with 2 generators> | |
| 96 | gap> G := aux[2]; | |
| 97 | <pc group of size 25 with 2 generators> | |
| 98 | </pre> | |
| 99 | <p> | |
| 100 | Next we have to pick some orbit representatives. | |
| 101 | We note that for a fixed Ferrero pair distinct choices of representatives | |
| 102 | may yield isomorphic nearrings. The function | |
| 103 | <code>OrbitRepresentativesForPlanarNearRing</code> returns exactly one set of | |
| 104 | representatives of given cardinality for each isomorphism class of planar | |
| 105 | nearrings which can be generated from (<i>G</i>, <font face="symbol">F</font>). | |
| 106 | <p> | |
| 107 | <pre> | |
| 108 | gap> OrbitRepresentativesForPlanarNearRing( G, phi, 1 ); | |
| 109 | [ [ f1 ] ] | |
| 110 | </pre> | |
| 111 | <p> | |
| 112 | This tells us that all planar nearrings obtained from (<i>G</i>,<font face="symbol">F</font>) with one | |
| 113 | orbit representative are in fact isomorphic. | |
| 114 | What happens if we choose 2 representatives? | |
| 115 | <p> | |
| 116 | <pre> | |
| 117 | gap> reps := OrbitRepresentativesForPlanarNearRing( G, phi, 2 ); | |
| 118 | [ [ f1, f1*f2 ], [ f1, f1^2*f2^2 ] ] | |
| 119 | </pre> | |
| 120 | <p> | |
| 121 | We obtain 2 non-isomorphic planar near-rings. Let's just construct one of | |
| 122 | them. The result will be an <code>ExplicitMultiplicationNearRing</code>. | |
| 123 | <p> | |
| 124 | <pre> | |
| 125 | gap> n := PlanarNearRing( G, phi, reps[1] ); | |
| 126 | ExplicitMultiplicationNearRing ( <pc group of size 25 with | |
| 127 | 2 generators> , multiplication ) | |
| 128 | </pre> | |
| 129 | <p> | |
| 130 | How many non-isomorphic planar nearrings can be defined from our Ferrero pair | |
| 131 | (<i>G</i>,<font face="symbol">F</font>) in total? Since there are 3 non-trivial orbits of <font face="symbol">F</font> on <i>G</i>, | |
| 132 | we may choose up to 3 representatives. | |
| 133 | <p> | |
| 134 | <pre> | |
| 135 | gap> Length(OrbitRepresentativesForPlanarNearRing( G, phi, 3 )); | |
| 136 | 6 | |
| 137 | </pre> | |
| 138 | <p> | |
| 139 | Summing all up, we get exactly 9 non-isomorphic planar nearrings with | |
| 140 | elementary abelian additive group of order 25 whose multiplication is | |
| 141 | defined using a quaternion group of fpf automorphisms. | |
| 142 | <p> | |
| 143 | <p> | |
| 144 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP006.htm">Previous</a>] [<a href ="CHAP008.htm">Next</a>] [<a href = "theindex.htm">Index</a>] | |
| 145 | <P> | |
| 146 | <address>SONATA-tutorial manual<br>October 2018 | |
| 147 | </address></body></html>⏎ |
| 0 | <html><head><title>[SONATA-tutorial] 8 Designs</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP007.htm">Previous</a>] [<a href = "theindex.htm">Index</a>] | |
| 3 | <h1>8 Designs</h1><p> | |
| 4 | <P> | |
| 5 | <H3>Sections</H3> | |
| 6 | <oL> | |
| 7 | <li> <A HREF="CHAP008.htm#SECT001">Designs from planar nearrings</a> | |
| 8 | <li> <A HREF="CHAP008.htm#SECT002">Information on designs</a> | |
| 9 | </ol><p> | |
| 10 | <p> | |
| 11 | Various designs can be obtained from nearrings. The design structure and | |
| 12 | basic functions for the manipulation of designs have been implemented within | |
| 13 | SONATA, as well as the means to construct the most popular nearring designs. | |
| 14 | Please see the reference manual for other ways to generate designs, e.g. | |
| 15 | by a set of blocks or by an incidence matrix. | |
| 16 | <p> | |
| 17 | <p> | |
| 18 | <h2><a name="SECT001">8.1 Designs from planar nearrings</a></h2> | |
| 19 | <p><p> | |
| 20 | We are going to generate a design with a feasible parameter set from a planar | |
| 21 | nearring, respectively from a Ferrero pair. | |
| 22 | For notations and definitions we refer to <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>]. | |
| 23 | <p> | |
| 24 | Let <i>N</i> be a (left) planar nearring. Then we can define a design | |
| 25 | (<i>N</i>,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) with <i>N</i> as the set of points and | |
| 26 | {<i>N</i><sup>*</sup>·<i>a</i>+<i>b</i> <font face="symbol">|</font> <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>N</i>, <i>a</i> <font face="symbol">¹</font> 0 } as set of blocks. | |
| 27 | Here <i>N</i><sup>*</sup> = { <i>x</i> <font face="symbol">Î</font> <i>N</i> <font face="symbol">|</font> <i>x</i>·<i>N</i> = <i>N</i> }. | |
| 28 | We note that such a design is always a BIB-design. Suppose that the planar | |
| 29 | nearring <i>N</i> is obtained from the Ferrero pair (<i>G</i>,<font face="symbol">F</font>) as described in the | |
| 30 | previous chapter with <i>v</i> : = <font face="symbol">|</font><i>G</i><font face="symbol">|</font>, <i>k</i> : = <font face="symbol">|</font><font face="symbol">F</font><font face="symbol">|</font>. | |
| 31 | We can identify <i>G</i> and the additive group of the nearring <i>N</i>. | |
| 32 | Then <i>N</i><sup>*</sup>·<i>a</i> = <font face="symbol">F</font>(<i>a</i>) for all <i>a</i> <font face="symbol">Î</font> <i>N</i>. The number of points of | |
| 33 | (<i>N</i>,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) is <i>v</i>, each block has size <i>k</i>, and any 2 distinct points | |
| 34 | are together incident with precisely <i>k</i><font face="symbol">-</font>1 blocks. We say that (<i>N</i>,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) | |
| 35 | is a 2<font face="symbol">-</font>(<i>v</i>,<i>k</i>,<i>k</i><font face="symbol">-</font>1) design. Note that <i>k</i> divides <i>v</i><font face="symbol">-</font>1. | |
| 36 | <p> | |
| 37 | <strong>The problem:</strong> | |
| 38 | Find a 2<font face="symbol">-</font>(16,5,4) design (<i>N</i>,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) if possible. | |
| 39 | <p> | |
| 40 | <strong>The solution:</strong> | |
| 41 | Since our design should have 16 points, we need a planar nearring of size | |
| 42 | 16. Furthermore, this planar nearring has an underlying Ferrero pair with | |
| 43 | a fixed-point-free (fpf) automorphism group of order 5, since the blocks | |
| 44 | should be of that size. | |
| 45 | <p> | |
| 46 | Let (<i>G</i>,<font face="symbol">F</font>) be such a Ferrero pair. | |
| 47 | We note that <font face="symbol">F</font> is fpf on all characteristic subgroups of <i>G</i>, in | |
| 48 | particular, on the center of <i>G</i>. For our example the size of the center | |
| 49 | modulo 5 has to be congruent to 1. Therefore the center has order 16, | |
| 50 | and <i>G</i> is abelian. | |
| 51 | Since <font face="symbol">F</font> is also fpf on any factor of <i>G</i> by a characteristic subgroup, | |
| 52 | <font face="symbol">F</font> is fpf on the factor of <i>G</i> by its Frattini subgroup. | |
| 53 | Thus <i>G</i> is elementary abelian. | |
| 54 | <p> | |
| 55 | Now we compute an fpf automorphism group of order 5 on the elementary abelian | |
| 56 | group of order 16: | |
| 57 | <p> | |
| 58 | <pre> | |
| 59 | gap> aux := FpfAutomorphismGroupsCyclic( [2,2,2,2], 5 ); | |
| 60 | [ [ [ f1, f2, f3, f4 ] -> [ f4, f1*f2, f2*f3, f3*f4 ] ], | |
| 61 | <pc group of size 16 with 4 generators> ] | |
| 62 | gap> a := aux[1][1]; | |
| 63 | [ f1, f2, f3, f4 ] -> [ f4, f1*f2, f2*f3, f3*f4 ] | |
| 64 | gap> phi := Group( a );; | |
| 65 | gap> G := aux[2];; | |
| 66 | </pre> | |
| 67 | <p> | |
| 68 | Up to conjugacy there is only one fpf automorphism group of order 5. | |
| 69 | We note that all planar nearrings obtained from a fixed Ferrero pair | |
| 70 | (<i>G</i>,<font face="symbol">F</font>) yield the same design. We build the blocks <font face="symbol">F</font>(<i>a</i>)+<i>b</i> for | |
| 71 | <i>a</i>,<i>b</i> <font face="symbol">Î</font> <i>G</i>, <i>a</i> <font face="symbol">¹</font> 0, of (<i>N</i>,<i>B</i><sup>*</sup>, <font face="symbol">Î</font> ) directly from (<i>G</i>,<font face="symbol">F</font>) without | |
| 72 | actually generating a nearring. | |
| 73 | <p> | |
| 74 | <pre> | |
| 75 | gap> D := DesignFromFerreroPair( G, phi, "*" ); | |
| 76 | <a 2 - ( 16, 5, 4 ) nearring generated design> | |
| 77 | </pre> | |
| 78 | <p> | |
| 79 | The reference manual describes other options for <code>DesignFromFerreroPair</code> | |
| 80 | besides <code>"*"</code> and the correponding designs as well. | |
| 81 | <p> | |
| 82 | <p> | |
| 83 | <h2><a name="SECT002">8.2 Information on designs</a></h2> | |
| 84 | <p><p> | |
| 85 | We investigate the design <code>D</code>, which we have generated from a planar | |
| 86 | nearring in the last section. | |
| 87 | <p> | |
| 88 | <pre> | |
| 89 | gap> D; | |
| 90 | <a 2 - ( 16, 5, 4 ) nearring generated design> | |
| 91 | gap> DesignParameter( D ); | |
| 92 | [ 2, 16, 48, 15, 5, 4 ] | |
| 93 | </pre> | |
| 94 | <p> | |
| 95 | <code>DesignParameter( D )</code> returns the set of parameters <i>t</i>, <i>v</i>, <i>b</i>, <i>r</i>, <i>k</i>, <font face="symbol">l</font> | |
| 96 | of the design <code>D</code>. Here there are 16 points, 48 blocks, | |
| 97 | every point is incident with precisely 15 blocks, every block is incident | |
| 98 | with precisely 5 points, every 2 distinct points are together incident | |
| 99 | with precisely 4 blocks. The design can be visualized by printing the | |
| 100 | incidence matrix. The rows are labelled by the points, the columns by | |
| 101 | the blocks. The point of number <i>i</i> is incident with the block of number <i>j</i> | |
| 102 | if and only if the entry in the <i>i</i>-th row, <i>j</i>-th column is 1. | |
| 103 | <p> | |
| 104 | <pre> | |
| 105 | gap> PrintIncidenceMat( D ); | |
| 106 | ...1...1...11...1...1..1..11..1...1..1..1...11.. | |
| 107 | 1......1...1..1.1...11...1..1..1...11..1..1....1 | |
| 108 | .1..1......11..1...1..1...11....1..1..11..1...1. | |
| 109 | ..1..1..1...1...1.1...1..1...11...1.1....11...1. | |
| 110 | 1....11..1......1..1.1....1.1...11...1...1..1.1. | |
| 111 | .1..1.1...1..1......11....1..11....11....1.1.1.. | |
| 112 | ..1..1.1.1...1...1...1...1.1....1.1...11...1.1.. | |
| 113 | ..11...1..1.1..1..1.....1...1...1..1.1...1.1...1 | |
| 114 | ..1.1...1.1...1..1.1.1.....1..1..1...1..1.1....1 | |
| 115 | 1...1.1....1.1...11...1.1.......1.1.1...1...1..1 | |
| 116 | 1...1...11....11....1..11....1....1..1.1...1..1. | |
| 117 | .1...1..1.1.1....1.1...11...1..1....1..1....11.. | |
| 118 | .1.1....11...1.1....1.1..1.1...1.1.......1..1..1 | |
| 119 | .1.1..1....1..1..11....1.1..1.1..1....1....1..1. | |
| 120 | ..11..1..1....1.1..1..1.1....1.1...1..1.1....1.. | |
| 121 | 1....1.1..1..1.1..1....1..1..1.1.1....1.1.1..... | |
| 122 | </pre> | |
| 123 | <p> | |
| 124 | By checking the entries in the incidence matrix we realize this design is | |
| 125 | circular, that is, any 2 distinct blocks have at most 2 points in common. | |
| 126 | Actually, this is not so easy to see. We prefer to do it like this: | |
| 127 | <p> | |
| 128 | <pre> | |
| 129 | gap> IsCircularDesign( D ); | |
| 130 | true | |
| 131 | </pre> | |
| 132 | <p> | |
| 133 | There are convenient functions to check which points are incident with | |
| 134 | a given set of blocks and vice versa. | |
| 135 | <p> | |
| 136 | <pre> | |
| 137 | gap> PointsIncidentBlocks( D, [2,7] ); | |
| 138 | [ 6, 14 ] | |
| 139 | gap> BlocksIncidentPoints( D, [6,14] ); | |
| 140 | [ 2, 7, 31, 44 ] | |
| 141 | </pre> | |
| 142 | <p> | |
| 143 | Here the 6-th and the 14-th point are incident with the given blocks with | |
| 144 | numbers 2 and 7. The numbering corresponds to that of the columns and rows of | |
| 145 | the incidence matrix. Blocks 2, 7, 31, and 44 are incident with points 6 and | |
| 146 | 14. | |
| 147 | <p> | |
| 148 | The cardinalities of the intersections of one block with all the others, | |
| 149 | e.g. of the 4-th block with all 48 blocks are given like this. | |
| 150 | <p> | |
| 151 | <pre> | |
| 152 | gap> BlockIntersectionNumbers( D, 4 ); | |
| 153 | [ 0, 2, 2, 5, 0, 0, 2, 2, 1, 2, 1, 2, 2, 1, 2, 2, 2, 1, 2, 1, 2, 0, | |
| 154 | 2, 2, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 1, 2, 0, 2, 2, 0, 2, 2, 0, 2, | |
| 155 | 2, 2, 1, 2 ] | |
| 156 | </pre> | |
| 157 | <p> | |
| 158 | Of course, all these functions can be applied to all kinds of designs no | |
| 159 | matter how they have been generated. | |
| 160 | <p> | |
| 161 | <p> | |
| 162 | [<a href = "chapters.htm">Up</a>] [<a href ="CHAP007.htm">Previous</a>] [<a href = "theindex.htm">Index</a>] | |
| 163 | <P> | |
| 164 | <address>SONATA-tutorial manual<br>October 2018 | |
| 165 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - References</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - References</h1><dl> | |
| 3 | </dl><p> | |
| 4 | [<a href="chapters.htm">Up</a>]<p> | |
| 5 | <P> | |
| 6 | <address>SONATA-tutorial manual<br>October 2018 | |
| 7 | </address></body></html> |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Chapters</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Chapters</h1> | |
| 3 | <ul> | |
| 4 | <li><a href="theindex.htm">Index</a> | |
| 5 | </ul> | |
| 6 | <ol> | |
| 7 | <li><a href="CHAP001.htm">Groups</a> | |
| 8 | <li><a href="CHAP002.htm">Nearrings</a> | |
| 9 | <li><a href="CHAP003.htm">The nearring library</a> | |
| 10 | <li><a href="CHAP004.htm">Nearrings of transformations on groups</a> | |
| 11 | <li><a href="CHAP005.htm">Some interesting nearrings</a> | |
| 12 | <li><a href="CHAP006.htm">Ideals, factors, and direct products of nearrings</a> | |
| 13 | <li><a href="CHAP007.htm">Planar nearrings</a> | |
| 14 | <li><a href="CHAP008.htm">Designs</a> | |
| 15 | </ol> | |
| 16 | <ul> | |
| 17 | <li><a href="biblio.htm">References</a> | |
| 18 | <li><a href="theindex.htm">Index</a> | |
| 19 | </ul><p> | |
| 20 | <P> | |
| 21 | <address>SONATA-tutorial manual<br>October 2018 | |
| 22 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index A</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index A</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>An application of the nearring library <a href="CHAP003.htm#SECT001">3.1</a> | |
| 18 | <dt>Appendix K revisited <a href="CHAP003.htm#SECT002">3.2</a> | |
| 19 | </dl><p> | |
| 20 | [<a href="chapters.htm">Up</a>]<p> | |
| 21 | <P> | |
| 22 | <address>SONATA-tutorial manual<br>October 2018 | |
| 23 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index C</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index C</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Centralizer nearrings <a href="CHAP005.htm#SECT003">5.3</a> | |
| 18 | </dl><p> | |
| 19 | [<a href="chapters.htm">Up</a>]<p> | |
| 20 | <P> | |
| 21 | <address>SONATA-tutorial manual<br>October 2018 | |
| 22 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index D</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index D</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Designs <a href="CHAP008.htm">8.0</a> | |
| 18 | <dt>Designs from planar nearrings <a href="CHAP008.htm#SECT001">8.1</a> | |
| 19 | <dt>Direct products <a href="CHAP006.htm#SECT001">6.1</a> | |
| 20 | </dl><p> | |
| 21 | [<a href="chapters.htm">Up</a>]<p> | |
| 22 | <P> | |
| 23 | <address>SONATA-tutorial manual<br>October 2018 | |
| 24 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index E</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index E</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Entering nearrings into the system <a href="CHAP002.htm#SECT001">2.1</a> | |
| 18 | <dt>Entering the nearring with less typing <a href="CHAP002.htm#SECT003">2.3</a> | |
| 19 | </dl><p> | |
| 20 | [<a href="chapters.htm">Up</a>]<p> | |
| 21 | <P> | |
| 22 | <address>SONATA-tutorial manual<br>October 2018 | |
| 23 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index F</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index F</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Finding a set of generators <a href="CHAP001.htm#SECT004">1.4</a> | |
| 18 | <dt>Finding affine complete groups <a href="CHAP005.htm#SECT004">5.4</a> | |
| 19 | </dl><p> | |
| 20 | [<a href="chapters.htm">Up</a>]<p> | |
| 21 | <P> | |
| 22 | <address>SONATA-tutorial manual<br>October 2018 | |
| 23 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index G</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index G</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Group endomorphisms <a href="CHAP001.htm#SECT003">1.3</a> | |
| 18 | <dt>Groups <a href="CHAP001.htm">1.0</a> | |
| 19 | </dl><p> | |
| 20 | [<a href="chapters.htm">Up</a>]<p> | |
| 21 | <P> | |
| 22 | <address>SONATA-tutorial manual<br>October 2018 | |
| 23 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index I</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index I</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Ideals and factors <a href="CHAP006.htm#SECT002">6.2</a> | |
| 18 | <dt>Ideals, factors, and direct products of nearrings <a href="CHAP006.htm">6.0</a> | |
| 19 | <dt>Information on designs <a href="CHAP008.htm#SECT002">8.2</a> | |
| 20 | </dl><p> | |
| 21 | [<a href="chapters.htm">Up</a>]<p> | |
| 22 | <P> | |
| 23 | <address>SONATA-tutorial manual<br>October 2018 | |
| 24 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index M</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index M</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>More information than just the size <a href="CHAP005.htm#SECT002">5.2</a> | |
| 18 | </dl><p> | |
| 19 | [<a href="chapters.htm">Up</a>]<p> | |
| 20 | <P> | |
| 21 | <address>SONATA-tutorial manual<br>October 2018 | |
| 22 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index N</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index N</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Nearrings <a href="CHAP002.htm">2.0</a> | |
| 18 | <dt>Nearrings generated by endomorphisms on a group <a href="CHAP005.htm#SECT001">5.1</a> | |
| 19 | <dt>Nearrings of transformations on groups <a href="CHAP004.htm">4.0</a> | |
| 20 | </dl><p> | |
| 21 | [<a href="chapters.htm">Up</a>]<p> | |
| 22 | <P> | |
| 23 | <address>SONATA-tutorial manual<br>October 2018 | |
| 24 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index P</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index P</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Planar nearrings <a href="CHAP007.htm">7.0</a> | |
| 18 | </dl><p> | |
| 19 | [<a href="chapters.htm">Up</a>]<p> | |
| 20 | <P> | |
| 21 | <address>SONATA-tutorial manual<br>October 2018 | |
| 22 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index S</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index S</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>Some interesting nearrings <a href="CHAP005.htm">5.0</a> | |
| 18 | <dt>Some simple questions about the nearring <a href="CHAP002.htm#SECT002">2.2</a> | |
| 19 | <dt>Subgroups <a href="CHAP001.htm#SECT002">1.2</a> | |
| 20 | </dl><p> | |
| 21 | [<a href="chapters.htm">Up</a>]<p> | |
| 22 | <P> | |
| 23 | <address>SONATA-tutorial manual<br>October 2018 | |
| 24 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index T</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index T</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | <dt>The nearring library <a href="CHAP003.htm">3.0</a> | |
| 18 | <dt>Thomas' and Wood's catalogue of small groups <a href="CHAP001.htm#SECT001">1.1</a> | |
| 19 | </dl><p> | |
| 20 | [<a href="chapters.htm">Up</a>]<p> | |
| 21 | <P> | |
| 22 | <address>SONATA-tutorial manual<br>October 2018 | |
| 23 | </address></body></html>⏎ |
| 0 | <html><head><title>SONATA-tutorial : a GAP 4 package - Index _</title></head> | |
| 1 | <body text="#000000" bgcolor="#ffffff"> | |
| 2 | <h1><font face="Gill Sans,Helvetica,Arial">SONATA-tutorial</font> : a <font face="Gill Sans,Helvetica,Arial">GAP</font> 4 package - Index _</h1> | |
| 3 | <p> | |
| 4 | <a href="theindex.htm">_</A> | |
| 5 | <a href="indxA.htm">A</A> | |
| 6 | <a href="indxC.htm">C</A> | |
| 7 | <a href="indxD.htm">D</A> | |
| 8 | <a href="indxE.htm">E</A> | |
| 9 | <a href="indxF.htm">F</A> | |
| 10 | <a href="indxG.htm">G</A> | |
| 11 | <a href="indxI.htm">I</A> | |
| 12 | <a href="indxM.htm">M</A> | |
| 13 | <a href="indxN.htm">N</A> | |
| 14 | <a href="indxP.htm">P</A> | |
| 15 | <a href="indxS.htm">S</A> | |
| 16 | <a href="indxT.htm">T</A> | |
| 17 | </dl><p> | |
| 18 | [<a href="chapters.htm">Up</a>]<p> | |
| 19 | <P> | |
| 20 | <address>SONATA-tutorial manual<br>October 2018 | |
| 21 | </address></body></html>⏎ |
| 212 | 212 | if Size( gamma ) = 1 then |
| 213 | 213 | return 1; |
| 214 | 214 | fi; |
| 215 | npc := NilpotencyClass( gamma ); | |
| 215 | npc := NilpotencyClassOfGroup( gamma ); | |
| 216 | 216 | if npc = fail or npc > 2 then |
| 217 | 217 | TryNextMethod(); |
| 218 | 218 | elif npc = 1 then |
| 0 | 0 | ################################################################################ |
| 1 | 1 | ## |
| 2 | 2 | #W expmulnr.gd Near-ring Library J"urgen Ecker |
| 3 | ## | |
| 4 | #H @(#)$Id: expmulnr.gd,v 1.2 2001/03/21 14:41:07 juergen Exp $ | |
| 5 | 3 | ## |
| 6 | 4 | #Y Copyright (C) |
| 7 | 5 | ## |
| 12 | 10 | ## Revision 1.1.1.1 2000/02/21 15:59:03 hetzi |
| 13 | 11 | ## Sonata Project Start |
| 14 | 12 | ## |
| 15 | ||
| 16 | expmulnr_gd:= | |
| 17 | "@(#)$Id: expmulnr.gd,v 1.2 2001/03/21 14:41:07 juergen Exp $"; | |
| 18 | 13 | |
| 19 | 14 | ############################################################################# |
| 20 | 15 | ## |
| 1 | 1 | ## |
| 2 | 2 | #W expmulnrnr.gi Near-ring Library J"urgen Ecker |
| 3 | 3 | ## |
| 4 | #H @(#)$Id: expmulnr.gi,v 1.8 2012/11/07 13:22:07 stein Exp $ | |
| 5 | ## | |
| 6 | ||
| 7 | ||
| 8 | 4 | |
| 9 | 5 | ## 13.01.00: N!.multiplication ersetzt, PM |
| 10 | ||
| 11 | ||
| 12 | expmulnrnr_gi:= | |
| 13 | "@(#)$Id: expmulnr.gi,v 1.8 2012/11/07 13:22:07 stein Exp $"; | |
| 14 | 6 | |
| 15 | 7 | ############################################################################# |
| 16 | 8 | ## |
| 94 | 94 | |
| 95 | 95 | ##################################################################### |
| 96 | 96 | ## |
| 97 | #A NilpotencyClass( <G> ) returns the nilpotency class of the group <G> | |
| 98 | ## | |
| 99 | ||
| 100 | DeclareAttribute( "NilpotencyClass", IsGroup ); | |
| 101 | ||
| 102 | ##################################################################### | |
| 103 | ## | |
| 104 | 97 | #F ScottSigma Scott's Sigma function |
| 105 | 98 | |
| 106 | 99 | DeclareGlobalFunction( "ScottSigma" ); |
| 226 | 226 | 1000, |
| 227 | 227 | G -> G ); |
| 228 | 228 | |
| 229 | InstallMethod( | |
| 230 | AsPermGroup, | |
| 231 | "PcGroups", | |
| 232 | true, | |
| 233 | [IsPcGroup and IsFinitelyGeneratedGroup], | |
| 234 | 0, | |
| 235 | function ( PcGroup ) | |
| 236 | return Image( IsomorphismPermGroup( PcGroup ), PcGroup ); | |
| 237 | end ); | |
| 238 | ||
| 239 | InstallMethod( | |
| 240 | AsPermGroup, | |
| 241 | "FpGroups", | |
| 242 | true, | |
| 243 | [IsFinitelyGeneratedGroup], | |
| 244 | 0, | |
| 245 | function ( FpGroup ) | |
| 246 | local PcGroup; | |
| 247 | if not IsMultiplicativeElementWithInverseByRws( FpGroup.1 ) then | |
| 248 | TryNextMethod(); | |
| 249 | fi; | |
| 250 | PcGroup := PcGroupFpGroup(FpGroup); | |
| 251 | return AsPermGroup( PcGroup ); | |
| 252 | end ); | |
| 253 | ||
| 254 | InstallMethod( | |
| 255 | AsPermGroup, | |
| 256 | "automorhism groups", | |
| 257 | true, | |
| 258 | [IsGroup], | |
| 259 | 10, | |
| 260 | function ( G ) | |
| 261 | return Action( G, AsList(G), OnRight ); | |
| 262 | end ); | |
| 229 | InstallMethod( AsPermGroup, [IsGroup], | |
| 230 | G -> Image( IsomorphismPermGroup( G ) ) ); | |
| 263 | 231 | |
| 264 | 232 | ##################################################################### |
| 265 | 233 | ## |
| 437 | 405 | |
| 438 | 406 | RmNSg := RepresentativesModNormalSubgroup( G, N ); |
| 439 | 407 | return RmNSg{[2..Length(RmNSg)]}; |
| 440 | end ); | |
| 441 | ||
| 442 | ############################################################################# | |
| 443 | ## | |
| 444 | #M NilpotencyClass | |
| 445 | ## | |
| 446 | ||
| 447 | InstallMethod( | |
| 448 | NilpotencyClass, | |
| 449 | "default", | |
| 450 | true, | |
| 451 | [IsGroup], | |
| 452 | 0, | |
| 453 | function ( G ) | |
| 454 | local l, LCS; | |
| 455 | LCS := LowerCentralSeries (G); | |
| 456 | l := Length (LCS); | |
| 457 | if Size (LCS[l]) = 1 then | |
| 458 | return l - 1; | |
| 459 | else | |
| 460 | return fail; | |
| 461 | fi; | |
| 462 | 408 | end ); |
| 463 | 409 | |
| 464 | 410 | ############################################################################# |
| 635 | 581 | [IsGroup], |
| 636 | 582 | 2, |
| 637 | 583 | function ( G ) |
| 638 | if not IsNilpotent( G ) or NilpotencyClass( G ) <> 2 then | |
| 584 | if not IsNilpotent( G ) or NilpotencyClassOfGroup( G ) <> 2 then | |
| 639 | 585 | TryNextMethod(); |
| 640 | 586 | fi; |
| 641 | 587 | |
| 1 | 1 | ## |
| 2 | 2 | #W grptfms.gd Near-ring Library Christof N"obauer |
| 3 | 3 | ## |
| 4 | #H @(#)$Id: grptfms.gd,v 1.8 2008/11/13 14:18:17 stein Exp $ | |
| 5 | ## | |
| 6 | 4 | #Y Copyright (C) |
| 7 | 5 | ## |
| 8 | 6 | ## $Log: grptfms.gd,v $ |
| 9 | ## Revision 1.8 2008/11/13 14:18:17 stein | |
| 7 | ## Revision 1.8 2008-11-13 14:18:17 stein | |
| 10 | 8 | ## Replaced IsNearRingEnumerator by IsTransformationNearRingEnumerator |
| 11 | 9 | ## |
| 12 | 10 | ## Revision 1.7 2002/01/18 07:20:50 erhard |
| 31 | 29 | ## Revision 1.1.1.1 2000/02/21 15:59:03 hetzi |
| 32 | 30 | ## Sonata Project Start |
| 33 | 31 | ## |
| 34 | ||
| 35 | grptfms_gd:= | |
| 36 | "@(#)$Id: grptfms.gd,v 1.8 2008/11/13 14:18:17 stein Exp $"; | |
| 37 | 32 | |
| 38 | 33 | DeclareOperation( "GroupGeneralMappingByGroupElement", |
| 39 | 34 | [IsGroup,IsMultiplicativeElementWithInverse] ); |
| 0 | 0 | ################################################################################ |
| 1 | 1 | ## |
| 2 | 2 | #W grptfms.gi Near-ring Library Christof N"obauer |
| 3 | ## | |
| 4 | #H @(#)$Id: grptfms.gi,v 1.15 2015/04/09 13:43:54 stein Exp $ | |
| 5 | 3 | ## |
| 6 | 4 | #Y Copyright (C) |
| 7 | 5 | ## |
| 52 | 50 | ## Revision 1.1.1.1 2000/02/21 15:59:03 hetzi |
| 53 | 51 | ## Sonata Project Start |
| 54 | 52 | ## |
| 55 | ||
| 56 | grptfms_gi:= | |
| 57 | "@(#)$Id: grptfms.gi,v 1.15 2015/04/09 13:43:54 stein Exp $"; | |
| 58 | 53 | |
| 59 | 54 | ############################################################################# |
| 60 | 55 | ## |
| 148 | 148 | #M IsSimpleNearRing |
| 149 | 149 | ## |
| 150 | 150 | |
| 151 | InstallImmediateMethod( | |
| 152 | IsSimpleNearRing, | |
| 153 | IsFullTransformationNearRing, | |
| 154 | 0, | |
| 155 | x -> true ); | |
| 156 | ||
| 157 | InstallImmediateMethod( | |
| 158 | IsSimpleNearRing, | |
| 159 | IsNearField, | |
| 160 | 0, | |
| 161 | x -> true ); | |
| 151 | InstallTrueMethod( IsSimpleNearRing, IsFullTransformationNearRing ); | |
| 152 | ||
| 153 | InstallTrueMethod( IsSimpleNearRing, IsNearField ); | |
| 162 | 154 | |
| 163 | 155 | InstallMethod( |
| 164 | 156 | IsSimpleNearRing, |
| 1 | 1 | ## |
| 2 | 2 | #W libnr.gi library near-rings Christof N"obauer |
| 3 | 3 | ## |
| 4 | #H @(#)$Id: libnr.gi,v 1.15 2007/07/19 22:43:43 stein Exp $ | |
| 5 | ## | |
| 6 | 4 | #Y Copyright (C) |
| 7 | 5 | ## |
| 8 | 6 | ## |
| 9 | 7 | ## 13.01.00 N!.multiplication ersetzt, PM |
| 10 | 8 | ## |
| 11 | libnr_gi:= | |
| 12 | "@(#)$Id: libnr.gi,v 1.15 2007/07/19 22:43:43 stein Exp $"; | |
| 13 | 9 | |
| 14 | 10 | ############################################################################## |
| 15 | 11 | ## |
| 1 | 1 | ## |
| 2 | 2 | #W nr.gd Near-ring Library J"urgen Ecker |
| 3 | 3 | ## |
| 4 | #H @(#)$Id: nr.gd,v 1.4 2007/05/09 22:45:31 stein Exp $ | |
| 5 | ## | |
| 6 | 4 | #Y Copyright (C) |
| 7 | 5 | ## |
| 8 | 6 | ## $Log: nr.gd,v $ |
| 9 | ## Revision 1.4 2007/05/09 22:45:31 stein | |
| 7 | ## Revision 1.4 2007-05-09 22:45:31 stein | |
| 10 | 8 | ## added functions IsNearRingUnit, NearRingUnits |
| 11 | 9 | ## |
| 12 | 10 | ## Revision 1.3 2002/01/17 18:25:52 juergen |
| 23 | 21 | |
| 24 | 22 | ## 13.01.00 PM: new attribute NRMultiplication |
| 25 | 23 | ## new attribute NRRowEndos |
| 26 | ||
| 27 | nr_gd:= | |
| 28 | "@(#)$Id: nr.gd,v 1.4 2007/05/09 22:45:31 stein Exp $"; | |
| 29 | 24 | |
| 30 | 25 | |
| 31 | 26 | ############################################################################# |
| 320 | 315 | ## corresponding to the elements n of <N> |
| 321 | 316 | ## |
| 322 | 317 | |
| 323 | DeclareAttribute( "NRRowEndos", IsNearRing, IsMutable ); | |
| 318 | DeclareAttribute( "NRRowEndos", IsNearRing, "mutable" ); | |
| 1 | 1 | ## |
| 2 | 2 | #W nr.gi Near-ring Library J"urgen Ecker |
| 3 | 3 | ## |
| 4 | #H @(#)$Id: nr.gi,v 1.10 2011/11/23 20:01:17 stein Exp $ | |
| 5 | ## | |
| 6 | 4 | #Y Copyright (C) |
| 7 | 5 | ## |
| 8 | 6 | ## $Log: nr.gi,v $ |
| 9 | ## Revision 1.10 2011/11/23 20:01:17 stein | |
| 7 | ## Revision 1.10 2011-11-23 20:01:17 stein | |
| 10 | 8 | ## New methods for Zero for elements of a nearring. |
| 11 | 9 | ## New methods for multiplying a nearring element with an integer (These should |
| 12 | 10 | ## be integrated into GAP in a future release and then removed from nr.gi). |
| 40 | 38 | ## Revision 1.1.1.1 2000/02/21 15:59:03 hetzi |
| 41 | 39 | ## Sonata Project Start |
| 42 | 40 | ## |
| 43 | ||
| 44 | nr_gi:= | |
| 45 | "@(#)$Id: nr.gi,v 1.10 2011/11/23 20:01:17 stein Exp $"; | |
| 46 | 41 | |
| 47 | 42 | ############################################################################# |
| 48 | 43 | ## |
| 529 | 524 | ## |
| 530 | 525 | #M IsPrimeNearRing |
| 531 | 526 | |
| 532 | InstallImmediateMethod( | |
| 533 | IsPrimeNearRing, | |
| 534 | IsNearRing and IsIntegralNearRing, | |
| 535 | 10, | |
| 536 | x -> true ); | |
| 527 | InstallTrueMethod( IsPrimeNearRing, IsNearRing and IsIntegralNearRing ); | |
| 537 | 528 | |
| 538 | 529 | InstallMethod( |
| 539 | 530 | IsPrimeNearRing, |
| 22 | 22 | ## |
| 23 | 23 | #I Ideal <=> LeftIdeal & RightIdeal |
| 24 | 24 | |
| 25 | InstallImmediateMethod( | |
| 26 | IsNearRingIdeal, | |
| 27 | IsNearRingLeftIdeal and IsNearRingRightIdeal, | |
| 28 | 10, | |
| 29 | x -> true ); | |
| 30 | ||
| 31 | InstallImmediateMethod( | |
| 32 | IsNearRingLeftIdeal, | |
| 33 | IsNearRingIdeal, | |
| 34 | 10, | |
| 35 | x -> true ); | |
| 36 | ||
| 37 | InstallImmediateMethod( | |
| 38 | IsNearRingRightIdeal, | |
| 39 | IsNearRingIdeal, | |
| 40 | 10, | |
| 41 | x -> true ); | |
| 25 | InstallTrueMethod( IsNearRingIdeal, IsNearRingLeftIdeal and IsNearRingRightIdeal ); | |
| 26 | InstallTrueMethod( IsNearRingLeftIdeal, IsNearRingIdeal ); | |
| 27 | InstallTrueMethod( IsNearRingRightIdeal, IsNearRingIdeal ); | |
| 42 | 28 | |
| 43 | 29 | ############################################################################# |
| 44 | 30 | ## |
| 120 | 120 | gap> G := aux[2]; |
| 121 | 121 | <pc group of size 25 with 2 generators> |
| 122 | 122 | gap> aux := FpfAutomorphismGroups4( [7,7], 3, 1, -1 ); |
| 123 | [ [ [ [ f1, f2 ] -> [ f1^2*f2^3, f1^3*f2^5 ], [ f1, f2 ] -> [ f2^6, f1 ], | |
| 123 | [ [ [ [ f1, f2 ] -> [ f1^2*f2^3, f1^3*f2^5 ], [ f1, f2 ] -> [ f2^6, f1 ], | |
| 124 | 124 | [ f1, f2 ] -> [ f1^2, f1*f2^4 ], |
| 125 | 125 | [ f1, f2 ] -> [ f1^5*f2^3, f1^3*f2^2 ] ] ], |
| 126 | 126 | <pc group of size 49 with 2 generators> ] |
| 269 | 269 | gap> PointsIncidentBlocks( D1, [1] ); |
| 270 | 270 | [ 2, 3, 4, 7 ] |
| 271 | 271 | gap> # block 1 is incident with points 2, 3, 4, 7 |
| 272 | gap> STOP_TEST( "fpf.tst", 10000);⏎ | |
| 272 | gap> STOP_TEST( "fpf.tst", 10000); | |
| 16 | 16 | false |
| 17 | 17 | gap> a := GroupReduct( n ); |
| 18 | 18 | 8/4 |
| 19 | gap> nsgps := NormalSubgroups( a ); | |
| 20 | [ 8/4, Group([ (1,2,3,4), (1,3)(2,4) ]), Group([ (1,4)(2,3), (1,3)(2,4) ]), | |
| 21 | Group([ (2,4), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(()) ] | |
| 19 | gap> nsgps := AsSortedList( NormalSubgroups( a ) );; | |
| 20 | gap> List(nsgps, StructureDescription);; | |
| 21 | gap> nsgps; | |
| 22 | [ 1, 8/4, C2 x C2, C2 x C2, C4, C2 ] | |
| 22 | 23 | gap> l := Filtered( nsgps, |
| 23 | 24 | > s -> IsSubgroupNearRingRightIdeal( n, s ) ); |
| 24 | [ 8/4, Group([ (2,4), (1,3)(2,4) ]), Group(()) ] | |
| 25 | [ 1, 8/4, C2 x C2 ] | |
| 25 | 26 | gap> l := List( l, |
| 26 | 27 | > s -> NearRingRightIdealBySubgroupNC( n, s ) ); |
| 27 | 28 | [ < nearring right ideal >, < nearring right ideal >, |
| 43 | 44 | [ true, false, false, false, true, true ] |
| 44 | 45 | gap> n := LibraryNearRingWithOne( GTW27_2, 5 ); |
| 45 | 46 | LibraryNearRingWithOne(27/2, 5) |
| 46 | gap> Filtered( NearRingIdeals( n ), IsPrimeNearRingIdeal ); | |
| 47 | gap> AsSortedList( Filtered( NearRingIdeals( n ), IsPrimeNearRingIdeal ) ); | |
| 47 | 48 | [ < nearring ideal of size 27 >, < nearring ideal of size 9 > ] |
| 48 | 49 | gap> n := LibraryNearRingWithOne( GTW27_2, 5 ); |
| 49 | 50 | LibraryNearRingWithOne(27/2, 5) |
| 52 | 53 | gap> n := LibraryNearRing( GTW8_2, 2 ); |
| 53 | 54 | LibraryNearRing(8/2, 2) |
| 54 | 55 | gap> li := NearRingLeftIdeals( n ); |
| 55 | [ < nearring left ideal >, < nearring left ideal >, < nearring left ideal >, | |
| 56 | [ < nearring left ideal >, < nearring left ideal >, < nearring left ideal >, | |
| 56 | 57 | < nearring left ideal >, < nearring left ideal >, < nearring left ideal > ] |
| 57 | 58 | gap> l := LibraryNearRing( GTW6_2, 3 ); |
| 58 | 59 | LibraryNearRing(6/2, 3) |
| 59 | gap> i := NearRingIdeals( l ); | |
| 60 | gap> i := AsSortedList( NearRingIdeals( l ) ); | |
| 60 | 61 | [ < nearring ideal >, < nearring ideal > ] |
| 61 | 62 | gap> List( i, Size ); |
| 62 | [ 6, 1 ] | |
| 63 | [ 1, 6 ] | |
| 63 | 64 | gap> NearRingCommutator( i[2], i[2] ); |
| 64 | < nearring ideal > | |
| 65 | < nearring ideal of size 6 > | |
| 65 | 66 | gap> l := LibraryNearRing( GTW8_4, 13 ); |
| 66 | 67 | LibraryNearRing(8/4, 13) |
| 67 | 68 | gap> NearRingIdeals( l ); |
| 69 | 70 | gap> NumberLibraryNearRings( GTW4_2 ); |
| 70 | 71 | 23 |
| 71 | 72 | gap> Filtered( AllLibraryNearRings( GTW4_2 ), IsSimpleNearRing ); |
| 72 | [ LibraryNearRing(4/2, 3), LibraryNearRing(4/2, 16), LibraryNearRing(4/2, 17) | |
| 73 | [ LibraryNearRing(4/2, 3), LibraryNearRing(4/2, 16), LibraryNearRing(4/2, 17) | |
| 73 | 74 | ] |
| 74 | 75 | gap> n := LibraryNearRing( GTW8_2, 2 ); |
| 75 | 76 | LibraryNearRing(8/2, 2) |
| 197 | 198 | fail |
| 198 | 199 | gap> N := LibraryNearRing( GTW12_3, 100 ); |
| 199 | 200 | LibraryNearRing(12/3, 100) |
| 200 | gap> I := NearRingIdeals( N ); | |
| 201 | gap> I := AsSortedList( NearRingIdeals( N ) ); | |
| 201 | 202 | [ < nearring ideal >, < nearring ideal >, < nearring ideal > ] |
| 202 | 203 | gap> List(I,Size); |
| 203 | [ 12, 6, 1 ] | |
| 204 | [ 1, 12, 6 ] | |
| 204 | 205 | gap> NN := NGroupByNearRingMultiplication( N ); |
| 205 | 206 | < N-group of LibraryNearRing(12/3, 100) > |
| 206 | 207 | gap> NoetherianQuotient( N, NN, GroupReduct(I[2]), GroupReduct(I[2]) ); |
| 216 | 217 | < nearring right ideal > |
| 217 | 218 | gap> Size( NuRadical( f, 0 ) ); |
| 218 | 219 | 8 |
| 219 | gap> AsList( NuRadical( f, 1 ) ); | |
| 220 | gap> AsSortedList( NuRadical( f, 1 ) ); | |
| 220 | 221 | [ (()), ((2,4)), ((1,2)(3,4)), ((1,2,3,4)), ((1,3)), ((1,3)(2,4)), |
| 221 | 222 | ((1,4,3,2)), ((1,4)(2,3)) ] |
| 222 | 223 | gap> NuRadical( f, 1/2 ) = NuRadical( f, 2 ); |
| 223 | 224 | true |
| 224 | gap> STOP_TEST( "tfms.tst", 10000);⏎ | |
| 225 | gap> STOP_TEST( "tfms.tst", 10000); | |
| 116 | 116 | gap> Length( Endomorphisms( GTW12_4 ) ); |
| 117 | 117 | 33 |
| 118 | 118 | gap> Automorphisms( LibraryNearRing( GTW12_4, 4 ) ); |
| 119 | [ IdentityMapping( 12/4 ) ] | |
| 119 | [ ^() ] | |
| 120 | 120 | gap> IsIsomorphicNearRing( MapNearRing( GTW2_1 ), |
| 121 | 121 | > LibraryNearRingWithOne( GTW4_2, 5 ) ); |
| 122 | 122 | true |
| 123 | 123 | gap> n := LibraryNearRing( GTW12_4, 8 ); |
| 124 | 124 | LibraryNearRing(12/4, 8) |
| 125 | 125 | gap> SubNearRings( n ); |
| 126 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 127 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3) ]) , multiplication ), | |
| 128 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 129 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 130 | ExplicitMultiplicationNearRing ( Group([ (1,2,4) ]) , multiplication ), | |
| 131 | ExplicitMultiplicationNearRing ( Group([ (1,3,2) ]) , multiplication ), | |
| 132 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 133 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3)(2,4) | |
| 134 | ]) , multiplication ), ExplicitMultiplicationNearRing ( Group( | |
| 135 | [ (1,4)(2,3), (1,3)(2,4), (2,3,4) ]) , multiplication ) ] | |
| 126 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 127 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3) ]) , multiplication ), | |
| 128 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 129 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 130 | ExplicitMultiplicationNearRing ( Group([ (1,2,4) ]) , multiplication ), | |
| 131 | ExplicitMultiplicationNearRing ( Group([ (1,3,2) ]) , multiplication ), | |
| 132 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 133 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3) | |
| 134 | (2,4) ]) , multiplication ), ExplicitMultiplicationNearRing ( Group([ (1,4) | |
| 135 | (2,3), (1,3)(2,4), (2,3,4) ]) , multiplication ) ] | |
| 136 | 136 | gap> n := LibraryNearRing( GTW12_4, 8 ); |
| 137 | 137 | LibraryNearRing(12/4, 8) |
| 138 | 138 | gap> i := InvariantSubNearRings( n ); |
| 139 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 140 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 141 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 142 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 143 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3)(2,4), (2,3,4) | |
| 144 | ]) , multiplication ) ] | |
| 139 | [ ExplicitMultiplicationNearRing ( Group(()) , multiplication ), | |
| 140 | ExplicitMultiplicationNearRing ( Group([ (1,2)(3,4) ]) , multiplication ), | |
| 141 | ExplicitMultiplicationNearRing ( Group([ (2,3,4) ]) , multiplication ), | |
| 142 | ExplicitMultiplicationNearRing ( Group([ (1,4,3) ]) , multiplication ), | |
| 143 | ExplicitMultiplicationNearRing ( Group([ (1,4)(2,3), (1,3) | |
| 144 | (2,4), (2,3,4) ]) , multiplication ) ] | |
| 145 | 145 | gap> n := LibraryNearRing( GTW12_4, 8 ); |
| 146 | 146 | LibraryNearRing(12/4, 8) |
| 147 | 147 | gap> S := Subgroup( GTW12_4, [ (1,2)(3,4) ] ); |
| 151 | 151 | gap> n := LibraryNearRingWithOne( GTW27_4, 5 ); |
| 152 | 152 | LibraryNearRingWithOne(27/4, 5) |
| 153 | 153 | gap> si := Filtered( SubNearRings( n ), s -> Identity( n ) in s ); |
| 154 | [ ExplicitMultiplicationNearRing ( Group( | |
| 155 | [ (1,23,14)(2,13,6)(3,27,22)(4,18,9)(5,20,12)(7,16,26)(8,25,17)(10,21, | |
| 156 | 19)(11,24,15) ]) , multiplication ), | |
| 157 | ExplicitMultiplicationNearRing ( Group( | |
| 158 | [ (1,22,16)(2,12,21)(3,26,23)(4,17,11)(5,19,13)(6,20,10)(7,14,27)(8,24, | |
| 159 | 18)(9,25,15), (1,26,27)(2,19,20)(3,14,16)(4,24,25)(5,6,21)(7,22,23)(8, | |
| 160 | 9,11)(10,12,13)(15,17,18) ]) , multiplication ), | |
| 161 | ExplicitMultiplicationNearRing ( Group( | |
| 162 | [ (1,6,15)(2,9,7)(3,13,25)(4,14,10)(5,18,27)(8,23,20)(11,22,19)(12,24, | |
| 163 | 16)(17,26,21), (1,5,17)(2,8,22)(3,12,4)(6,18,26)(7,20,11)(9,23,19)(10, | |
| 164 | 25,16)(13,24,14)(15,27,21), (1,2,4)(3,6,11)(5,9,16)(7,13,17)(8,14, | |
| 165 | 21)(10,18,22)(12,15,23)(19,24,26)(20,25,27) ]) , multiplication ) ] | |
| 154 | [ ExplicitMultiplicationNearRing ( Group([ (1,23,14)(2,13,6)(3,27,22)(4,18,9) | |
| 155 | (5,20,12)(7,16,26)(8,25,17)(10,21,19)(11,24,15) ]) , multiplication ), | |
| 156 | ExplicitMultiplicationNearRing ( Group([ (1,22,16)(2,12,21)(3,26,23) | |
| 157 | (4,17,11)(5,19,13)(6,20,10)(7,14,27)(8,24,18)(9,25,15), (1,26,27)(2,19,20) | |
| 158 | (3,14,16)(4,24,25)(5,6,21)(7,22,23)(8,9,11)(10,12,13) | |
| 159 | (15,17,18) ]) , multiplication ), | |
| 160 | ExplicitMultiplicationNearRing ( Group([ (1,6,15)(2,9,7)(3,13,25)(4,14,10) | |
| 161 | (5,18,27)(8,23,20)(11,22,19)(12,24,16)(17,26,21), (1,5,17)(2,8,22)(3,12,4) | |
| 162 | (6,18,26)(7,20,11)(9,23,19)(10,25,16)(13,24,14)(15,27,21), (1,2,4)(3,6,11) | |
| 163 | (5,9,16)(7,13,17)(8,14,21)(10,18,22)(12,15,23)(19,24,26) | |
| 164 | (20,25,27) ]) , multiplication ) ] | |
| 166 | 165 | gap> Intersection( si ); |
| 167 | ExplicitMultiplicationNearRing ( Group( | |
| 168 | [ (1,23,14)(2,13,6)(3,27,22)(4,18,9)(5,20,12)(7,16,26)(8,25,17)(10,21,19)(11, | |
| 169 | 24,15) ]) , multiplication ) | |
| 166 | ExplicitMultiplicationNearRing ( Group([ (1,23,14)(2,13,6)(3,27,22)(4,18,9) | |
| 167 | (5,20,12)(7,16,26)(8,25,17)(10,21,19)(11,24,15) ]) , multiplication ) | |
| 170 | 168 | gap> Size( last ); |
| 171 | 169 | 3 |
| 172 | 170 | gap> n := LibraryNearRing( GTW12_4, 8 ); |
| 245 | 243 | gap> IsRegularNearRing( n ); |
| 246 | 244 | false |
| 247 | 245 | gap> IsNearField( n ); |
| 248 | false | |
| 246 | false | |
| 249 | 247 | gap> n := LibraryNearRing( GTW9_2, 90 ); |
| 250 | 248 | LibraryNearRing(9/2, 90) |
| 251 | 249 | gap> IsPlanarNearRing( n ); |
| 288 | 286 | gap> IsLibraryNearRing( LNwI24_4_8 ); |
| 289 | 287 | true |
| 290 | 288 | gap> STOP_TEST( "nr.tst", 10000); |
| 291 | ||
| 292 | ||
| 293 | ||
| 294 | ||
| 295 | ||
| 0 | LoadPackage("sonata"); | |
| 1 | dir := DirectoriesPackageLibrary("sonata", "tst"); | |
| 2 | TestDirectory(dir, rec(exitGAP := true)); | |
| 3 | ||
| 4 | FORCE_QUIT_GAP(1); | |
| 5 |
| 27 | 27 | gap> IsEndoMapping ( InnerAutomorphisms ( GTW6_2 ) [3] ); |
| 28 | 28 | true |
| 29 | 29 | gap> AsList ( UnderlyingRelation ( IdentityEndoMapping ( Group ((1,2,3,4)) ) ) ); |
| 30 | [ DirectProductElement( [ (), () ] ), DirectProductElement( [ (1,2,3,4), | |
| 31 | (1,2,3,4) ] ), DirectProductElement( [ (1,3)(2,4), (1,3)(2,4) ] ), | |
| 30 | [ DirectProductElement( [ (), () ] ), DirectProductElement( [ (1,2,3,4), (1,2, | |
| 31 | 3,4) ] ), DirectProductElement( [ (1,3)(2,4), (1,3)(2,4) ] ), | |
| 32 | 32 | DirectProductElement( [ (1,4,3,2), (1,4,3,2) ] ) ] |
| 33 | 33 | gap> C3 := CyclicGroup (3); |
| 34 | 34 | <pc group of size 3 with 1 generators> |
| 79 | 79 | gap> m := ConstantEndoMapping (G, (1,2,3)) + IdentityEndoMapping( G ); |
| 80 | 80 | MappingByFunction( Sym( [ 1 .. 3 ] ), Sym( [ 1 .. 3 ] ), function( g ) ... end\ |
| 81 | 81 | ) |
| 82 | gap> PrintArray( GraphOfMapping( m ) ); | |
| 82 | gap> PrintArray( AsSortedList( GraphOfMapping( m ) ) ); | |
| 83 | 83 | [ [ (), (1,2,3) ], |
| 84 | 84 | [ (2,3), (1,3) ], |
| 85 | 85 | [ (1,2), (2,3) ], |
| 89 | 89 | gap> g := AlternatingGroup ( 4 ); |
| 90 | 90 | Alt( [ 1 .. 4 ] ) |
| 91 | 91 | gap> AsSortedList ( g ); |
| 92 | [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), (1,3,4), | |
| 92 | [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), (1,3,4), | |
| 93 | 93 | (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ] |
| 94 | 94 | gap> t := EndoMappingByPositionList ( g, [1,3,4,5,2,1,1,1,1,1,1,1] ); |
| 95 | 95 | <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup( [ 1 .. 4 ] ) > |
| 157 | 157 | gap> Size ( C0 ); |
| 158 | 158 | 32 |
| 159 | 159 | gap> Is := NearRingIdeals ( C0 ); |
| 160 | [ < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 161 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 162 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 163 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 160 | [ < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 161 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 162 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 163 | < nearring ideal >, < nearring ideal >, < nearring ideal >, | |
| 164 | 164 | < nearring ideal > ] |
| 165 | 165 | gap> G := GTW16_8; |
| 166 | 166 | 16/8 |
| 168 | 168 | > x -> Size (x) = 2 ); |
| 169 | 169 | Group([ (1,5)(2,10)(3,11)(4,12)(6,15)(7,16)(8,9)(13,14) ]) |
| 170 | 170 | gap> HGU := RestrictedEndomorphismNearRing (G, U); |
| 171 | RestrictedEndomorphismNearRing( 16/8, Group( | |
| 172 | [ (1,5)(2,10)(3,11)(4,12)(6,15)(7,16)(8,9)(13,14) ]) ) | |
| 171 | RestrictedEndomorphismNearRing( 16/8, Group([ (1,5)(2,10)(3,11)(4,12)(6,15) | |
| 172 | (7,16)(8,9)(13,14) ]) ) | |
| 173 | 173 | gap> Size (HGU); |
| 174 | 174 | 8 |
| 175 | 175 | gap> IsDistributiveNearRing ( HGU ); |
| 196 | 196 | gap> P := PolynomialNearRing ( GTW4_2 ); |
| 197 | 197 | PolynomialNearRing( 4/2 ) |
| 198 | 198 | gap> n := AsExplicitMultiplicationNearRing ( P ); |
| 199 | ExplicitMultiplicationNearRing ( Group( | |
| 200 | [ (1,2)(5,6)(9,10)(13,14), (3,4)(7,8)(11,12)(15,16), | |
| 201 | (7,8)(9,10)(13,14)(15,16) ]) , multiplication ) | |
| 199 | ExplicitMultiplicationNearRing ( Group([ (1,2)(5,6)(9,10)(13,14), (3,4)(7,8) | |
| 200 | (11,12)(15,16), (7,8)(9,10)(13,14)(15,16) ]) , multiplication ) | |
| 202 | 201 | gap> G := SymmetricGroup ( 4 ); |
| 203 | 202 | Sym( [ 1 .. 4 ] ) |
| 204 | gap> V := First ( NormalSubgroups ( G ), x -> Size ( x ) = 4 ); | |
| 203 | gap> V := Group([ (1,4)(2,3), (1,3)(2,4) ]); | |
| 205 | 204 | Group([ (1,4)(2,3), (1,3)(2,4) ]) |
| 206 | 205 | gap> P := InnerAutomorphismNearRing ( G ); |
| 207 | 206 | InnerAutomorphismNearRing( Sym( [ 1 .. 4 ] ) ) |
| 213 | 212 | 8/4 |
| 214 | 213 | gap> P := PolynomialNearRing (G); |
| 215 | 214 | PolynomialNearRing( 8/4 ) |
| 216 | gap> A := TrivialSubgroup (G); | |
| 217 | Group(()) | |
| 215 | gap> A := TrivialSubgroup (G);; | |
| 218 | 216 | gap> B := DerivedSubgroup (G); |
| 219 | 217 | Group([ (1,3)(2,4) ]) |
| 220 | 218 | gap> C := G; |
| 233 | 231 | < transformation nearring with 3 generators > |
| 234 | 232 | gap> I = Zp; |
| 235 | 233 | true |
| 236 | gap> STOP_TEST( "tfms.tst", 10000);⏎ | |
| 234 | gap> STOP_TEST( "tfms.tst", 10000); | |