This file is indexed.

/usr/share/gap/doc/ref/chap31.html is in gap-doc 4r8p8-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (ref) - Chapter 31: Domains and their Elements</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap31"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chap16.html">16</a>  <a href="chap17.html">17</a>  <a href="chap18.html">18</a>  <a href="chap19.html">19</a>  <a href="chap20.html">20</a>  <a href="chap21.html">21</a>  <a href="chap22.html">22</a>  <a href="chap23.html">23</a>  <a href="chap24.html">24</a>  <a href="chap25.html">25</a>  <a href="chap26.html">26</a>  <a href="chap27.html">27</a>  <a href="chap28.html">28</a>  <a href="chap29.html">29</a>  <a href="chap30.html">30</a>  <a href="chap31.html">31</a>  <a href="chap32.html">32</a>  <a href="chap33.html">33</a>  <a href="chap34.html">34</a>  <a href="chap35.html">35</a>  <a href="chap36.html">36</a>  <a href="chap37.html">37</a>  <a href="chap38.html">38</a>  <a href="chap39.html">39</a>  <a href="chap40.html">40</a>  <a href="chap41.html">41</a>  <a href="chap42.html">42</a>  <a href="chap43.html">43</a>  <a href="chap44.html">44</a>  <a href="chap45.html">45</a>  <a href="chap46.html">46</a>  <a href="chap47.html">47</a>  <a href="chap48.html">48</a>  <a href="chap49.html">49</a>  <a href="chap50.html">50</a>  <a href="chap51.html">51</a>  <a href="chap52.html">52</a>  <a href="chap53.html">53</a>  <a href="chap54.html">54</a>  <a href="chap55.html">55</a>  <a href="chap56.html">56</a>  <a href="chap57.html">57</a>  <a href="chap58.html">58</a>  <a href="chap59.html">59</a>  <a href="chap60.html">60</a>  <a href="chap61.html">61</a>  <a href="chap62.html">62</a>  <a href="chap63.html">63</a>  <a href="chap64.html">64</a>  <a href="chap65.html">65</a>  <a href="chap66.html">66</a>  <a href="chap67.html">67</a>  <a href="chap68.html">68</a>  <a href="chap69.html">69</a>  <a href="chap70.html">70</a>  <a href="chap71.html">71</a>  <a href="chap72.html">72</a>  <a href="chap73.html">73</a>  <a href="chap74.html">74</a>  <a href="chap75.html">75</a>  <a href="chap76.html">76</a>  <a href="chap77.html">77</a>  <a href="chap78.html">78</a>  <a href="chap79.html">79</a>  <a href="chap80.html">80</a>  <a href="chap81.html">81</a>  <a href="chap82.html">82</a>  <a href="chap83.html">83</a>  <a href="chap84.html">84</a>  <a href="chap85.html">85</a>  <a href="chap86.html">86</a>  <a href="chap87.html">87</a>  <a href="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

<div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp;  <a href="chap0.html#contents">[Contents]</a>&nbsp;  &nbsp;<a href="chap30.html">[Previous Chapter]</a>&nbsp;  &nbsp;<a href="chap32.html">[Next Chapter]</a>&nbsp;  </div>

<p id="mathjaxlink" class="pcenter"><a href="chap31_mj.html">[MathJax on]</a></p>
<p><a id="X7E651AC287AFDCC1" name="X7E651AC287AFDCC1"></a></p>
<div class="ChapSects"><a href="chap31.html#X7E651AC287AFDCC1">31 <span class="Heading">Domains and their Elements</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X859C7AB97B34F55F">31.1 <span class="Heading">Operational Structure of Domains</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X84FA03F87A17B059">31.2 <span class="Heading">Equality and Comparison of Domains</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X82039A218274826F">31.3 <span class="Heading">Constructing Domains</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7EA77DE17DD8A231">31.4 <span class="Heading">Changing the Structure</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X860FCCBE7A41412F">31.5 <span class="Heading">Changing the Representation</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7D72F11B82F4A036">31.6 <span class="Heading">Domain Categories</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7CBDD36E7B7BE286">31.7 <span class="Heading">Parents</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7BC856CC7F116BB0">31.7-1 Parent</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7B58FDEF80338DD6">31.8 <span class="Heading">Constructing Subdomains</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X86D579707B112970">31.9 <span class="Heading">Operations for Domains</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X86B4AC017FAF4D12">31.9-1 IsGeneralizedDomain</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7E353DD1838AB223">31.9-2 GeneratorsOfDomain</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X826A21287FD3ACC0">31.9-3 Domain</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7C2B0C1280237CB0">31.10 <span class="Heading">Attributes and Properties of Elements</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X81278E53800BF64D">31.10-1 Characteristic</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X8046262384895B2A">31.10-2 OneImmutable</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X8040AC7A79FFC442">31.10-3 ZeroImmutable</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X86DEB543824C40EB">31.10-4 MultiplicativeZeroOp</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X814D78347858EC13">31.10-5 IsOne</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X82BDA47282F9BBA7">31.10-6 IsZero</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7CB5896082D29173">31.10-7 IsIdempotent</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X78EE524E83624057">31.10-8 InverseImmutable</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X84BB723C81D55D63">31.10-9 AdditiveInverseImmutable</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X84F59A2687C62763">31.10-10 Order</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7B3BC7BA7BB2646D">31.11 <span class="Heading">Comparison Operations for Elements</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7EF67D047F03CA6F">31.11-1 <span class="Heading">\= and \&lt;</span></a>
</span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7EFE013B8634D214">31.11-2 CanEasilyCompareElements</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7A2914307963E370">31.12 <span class="Heading">Arithmetic Operations for Elements</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X8481C9B97B214C23">31.12-1 <span class="Heading">\+, \*, \/, \^, \mod</span></a>
</span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7A37082878DB3930">31.12-2 LeftQuotient</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X80761843831B468E">31.12-3 Comm</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X86A62A937A42B82E">31.12-4 LieBracket</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7E8F1FB87C229BB0">31.12-5 Sqrt</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X80A2D8A7874B268B">31.13 <span class="Heading">Relations Between Domains</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7C03098C838ADE40">31.13-1 UseSubsetRelation</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X78039B628262BFA8">31.13-2 UseFactorRelation</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X839BE6467E8474D9">31.13-3 UseIsomorphismRelation</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X863C35007C7AA914">31.13-4 InstallSubsetMaintenance</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7BB7EE5078EF6F47">31.13-5 InstallFactorMaintenance</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X79F97F0F78D89186">31.13-6 InstallIsomorphismMaintenance</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7B97A0307EA161E5">31.14 <span class="Heading">Useful Categories of Elements</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7FBD4F65861C2DF2">31.14-1 IsExtAElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7F346AA47AEC39AB">31.14-2 IsNearAdditiveElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X78D042B486E1D7F7">31.14-3 IsAdditiveElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7CE2353F836F6E0A">31.14-4 IsNearAdditiveElementWithZero</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X87F3552A789C572D">31.14-5 IsAdditiveElementWithZero</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X84B0929982B51CB4">31.14-6 IsNearAdditiveElementWithInverse</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7C0E4AE883947778">31.14-7 IsAdditiveElementWithInverse</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X860D1E387DD5CCCF">31.14-8 IsExtLElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X809E0C097E480AF1">31.14-9 IsExtRElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X797D3B2A7A2B2F53">31.14-10 IsMultiplicativeElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X82BC294F7D388AE8">31.14-11 IsMultiplicativeElementWithOne</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X8703BFC2841BBD63">31.14-12 IsMultiplicativeElementWithZero</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7FDB14E57814FA3B">31.14-13 IsMultiplicativeElementWithInverse</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X802F34F280B29DF4">31.14-14 IsVector</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X799AEDE180C31276">31.14-15 IsNearRingElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X84BF40CA86C07361">31.14-16 IsRingElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7C724689784EEF3D">31.14-17 IsNearRingElementWithOne</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X875B67208017608E">31.14-18 IsRingElementWithOne</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X80CD04ED85B6B2F9">31.14-19 IsNearRingElementWithInverse</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X8113834E84FD0435">31.14-20 IsRingElementWithInverse</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap31.html#X7ABEF00C870789D2">31.15 <span class="Heading">Useful Categories for all Elements of a Family</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7979AFAA80FF795A">31.15-1 IsAssociativeElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X78A286418205CE44">31.15-2 IsAdditivelyCommutativeElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X8137FA8D86714AC0">31.15-3 IsCommutativeElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X810D2E5E832594AA">31.15-4 IsFiniteOrderElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X796957D0805A0221">31.15-5 IsJacobianElement</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap31.html#X7844399D7847AB24">31.15-6 IsZeroSquaredElement</a></span>
</div></div>
</div>

<h3>31 <span class="Heading">Domains and their Elements</span></h3>

<p><em>Domain</em> is <strong class="pkg">GAP</strong>'s name for structured sets. The ring of Gaussian integers <span class="SimpleMath">ℤ[sqrt{-1}]</span> is an example of a domain, the group <span class="SimpleMath">D_12</span> of symmetries of a regular hexahedron is another.</p>

<p>The <strong class="pkg">GAP</strong> library predefines some domains. For example the ring of Gaussian integers is predefined as <code class="func">GaussianIntegers</code> (<a href="chap60.html#X80BD5EAB879F096E"><span class="RefLink">60.5-1</span></a>) (see <a href="chap60.html#X85E9E90D7FE877CC"><span class="RefLink">60.5</span></a>) and the field of rationals is predefined as <code class="func">Rationals</code> (<a href="chap17.html#X7B6029D18570C08A"><span class="RefLink">17.1-1</span></a>) (see <a href="chap17.html#X87003045878E74DF"><span class="RefLink">17</span></a>). Most domains are constructed by functions, which are called <em>domain constructors</em> (see <a href="chap31.html#X82039A218274826F"><span class="RefLink">31.3</span></a>). For example the group <span class="SimpleMath">D_12</span> is constructed by the construction <code class="code">Group( (1,2,3,4,5,6), (2,6)(3,5) )</code> (see <code class="func">Group</code> (<a href="chap39.html#X7D8E473384DE9CD4"><span class="RefLink">39.2-1</span></a>)) and the finite field with 16 elements is constructed by <code class="code">GaloisField( 16 )</code> (see <code class="func">GaloisField</code> (<a href="chap59.html#X8592DBB086A8A9BE"><span class="RefLink">59.3-2</span></a>)).</p>

<p>The first place where you need domains in <strong class="pkg">GAP</strong> is the obvious one. Sometimes you simply want to deal with a domain. For example if you want to compute the size of the group <span class="SimpleMath">D_12</span>, you had better be able to represent this group in a way that the <code class="func">Size</code> (<a href="chap30.html#X858ADA3B7A684421"><span class="RefLink">30.4-6</span></a>) function can understand.</p>

<p>The second place where you need domains in <strong class="pkg">GAP</strong> is when you want to be able to specify that an operation or computation takes place in a certain domain. For example suppose you want to factor 10 in the ring of Gaussian integers. Saying <code class="code">Factors( 10 )</code> will not do, because this will return the factorization <code class="code">[ 2, 5 ]</code> in the ring of integers. To allow operations and computations to happen in a specific domain, <code class="func">Factors</code> (<a href="chap56.html#X82D6EDC685D12AE2"><span class="RefLink">56.5-9</span></a>), and many other functions as well, accept this domain as optional first argument. Thus <code class="code">Factors( GaussianIntegers, 10 )</code> yields the desired result <code class="code">[ 1+E(4), 1-E(4), 2+E(4), 2-E(4) ]</code>. (The imaginary unit <span class="SimpleMath">sqrt{-1}</span> is written as <code class="code">E(4)</code> in <strong class="pkg">GAP</strong>, see <code class="func">E</code> (<a href="chap18.html#X8631458886314588"><span class="RefLink">18.1-1</span></a>).)</p>

<p>An introduction to the most important facts about domains is given in Chapter <a href="../../doc/tut/chap7.html#X7BAF69417BB925F6"><span class="RefLink">Tutorial: Domains</span></a>.</p>

<p>There are only few <em>operations</em> especially for domains (see <a href="chap31.html#X86D579707B112970"><span class="RefLink">31.9</span></a>), operations such as <code class="func">Intersection</code> (<a href="chap30.html#X851069107CACF98E"><span class="RefLink">30.5-2</span></a>) and <code class="func">Random</code> (<a href="chap30.html#X7FF906E57D6936F8"><span class="RefLink">30.7-1</span></a>) are defined for the more general situation of collections (see Chapter <a href="chap30.html#X8050A8037984E5B6"><span class="RefLink">30</span></a>).</p>

<p><a id="X859C7AB97B34F55F" name="X859C7AB97B34F55F"></a></p>

<h4>31.1 <span class="Heading">Operational Structure of Domains</span></h4>

<p>Domains have an <em>operational structure</em>, that is, a collection of operations under which the domain is closed. For example, a group is closed under multiplication, taking the zeroth power of elements, and taking inverses of elements. The operational structure may be empty, examples of domains without additional structure are the underlying relations of general mappings (see <a href="chap32.html#X7E5A430D7F838F1C"><span class="RefLink">32.3</span></a>).</p>

<p>The operations under which a domain is closed are a subset of the operations that the elements of a domain admit. It is possible that the elements admit more operations. For example, matrices can be multiplied and added. But addition plays no role in a group of matrices, and multiplication plays no role in a vector space of matrices. In particular, a matrix group is not closed under addition.</p>

<p>Note that the elements of a domain exist independently of this domain, usually they existed already before the domain was created. So it makes sense to say that a domain is <em>generated</em> by some elements with respect to certain operations.</p>

<p>Of course, different sets of operations yield different notions of generation. For example, the group generated by some matrices is different from the ring generated by these matrices, and these two will in general be different from the vector space generated by the same matrices, over a suitable field.</p>

<p>The other way round, the same set of elements may be obtained by generation w.r.t. different notions of generation. For example, one can get the group generated by two elements <span class="SimpleMath">g</span> and <span class="SimpleMath">h</span> also as the monoid generated by the elements <span class="SimpleMath">g</span>, <span class="SimpleMath">g^{-1}</span>, <span class="SimpleMath">h</span>, <span class="SimpleMath">h^{-1}</span>; if both <span class="SimpleMath">g</span> and <span class="SimpleMath">h</span> have finite order then of course the group generated by <span class="SimpleMath">g</span> and <span class="SimpleMath">h</span> coincides with the monoid generated by <span class="SimpleMath">g</span> and <span class="SimpleMath">h</span>.</p>

<p>Additionally to the operational structure, a domain can have properties. For example, the multiplication of a group is associative, and the multiplication in a field is commutative.</p>

<p>Note that associativity and commutativity depend on the set of elements for which one considers the multiplication, i.e., it depends on the domain. For example, the multiplication in a full matrix ring over a field is not commutative, whereas its restriction to the set of diagonal matrices is commutative.</p>

<p>One important difference between the operational structure and the properties of a domain is that the operational structure is fixed when the domain is constructed, whereas properties can be discovered later. For example, take a domain whose operational structure is given by closure under multiplication. If it is discovered that the inverses of all its elements also do (by chance) lie in this domain, being closed under taking inverses is <em>not</em> added to the operational structure. But a domain with operational structure of multiplication, taking the identity, and taking inverses will be treated as a group as soon as the multiplication is found out to be associative for this domain.</p>

<p>The operational structures available in <strong class="pkg">GAP</strong> form a hierarchy, which is explicitly formulated in terms of domain categories, see <a href="chap31.html#X7D72F11B82F4A036"><span class="RefLink">31.6</span></a>.</p>

<p><a id="X84FA03F87A17B059" name="X84FA03F87A17B059"></a></p>

<h4>31.2 <span class="Heading">Equality and Comparison of Domains</span></h4>

<p><em>Equality</em> and <em>comparison</em> of domains are defined as follows.</p>

<p>Two domains are considered <em>equal</em> if and only if the sets of their elements as computed by <code class="func">AsSSortedList</code> (<a href="chap30.html#X856D927378C33548"><span class="RefLink">30.3-10</span></a>)) are equal. Thus, in general <code class="code">=</code> behaves as if each domain operand were replaced by its set of elements. Except that <code class="code">=</code> will also sometimes, but not always, work for infinite domains, for which of course <strong class="pkg">GAP</strong> cannot compute the set of elements. Note that this implies that domains with different algebraic structure may well be equal. As a special case of this, either operand of <code class="code">=</code> may also be a proper set (see <a href="chap21.html#X80ABC25582343910"><span class="RefLink">21.19</span></a>), i.e., a sorted list without holes or duplicates (see <code class="func">AsSSortedList</code> (<a href="chap30.html#X856D927378C33548"><span class="RefLink">30.3-10</span></a>)), and <code class="code">=</code> will return <code class="keyw">true</code> if and only if this proper set is equal to the set of elements of the argument that is a domain.</p>

<p><em>No</em> general <em>ordering</em> of arbitrary domains via <code class="code">&lt;</code> is defined in <strong class="pkg">GAP</strong> 4. This is because a well-defined <code class="code">&lt;</code> for domains or, more general, for collections, would have to be compatible with <code class="code">=</code> and would need to be transitive and antisymmetric in order to be used to form ordered sets. In particular, <code class="code">&lt;</code> would have to be independent of the algebraic structure of its arguments because this holds for <code class="code">=</code>, and thus there would be hardly a situation where one could implement an efficient comparison method. (Note that in the case that two domains are comparable with <code class="code">&lt;</code>, the result is in general <em>not</em> compatible with the set theoretical subset relation, which can be decided with <code class="func">IsSubset</code> (<a href="chap30.html#X79CA175481F8105F"><span class="RefLink">30.5-1</span></a>).)</p>

<p><a id="X82039A218274826F" name="X82039A218274826F"></a></p>

<h4>31.3 <span class="Heading">Constructing Domains</span></h4>

<p>For several operational structures (see <a href="chap31.html#X859C7AB97B34F55F"><span class="RefLink">31.1</span></a>), <strong class="pkg">GAP</strong> provides functions to construct domains with this structure (note that such functions do not exist for all operational structures). For example, <code class="func">Group</code> (<a href="chap39.html#X7D8E473384DE9CD4"><span class="RefLink">39.2-1</span></a>) returns groups, <code class="func">VectorSpace</code> (<a href="chap61.html#X805413157CE9BECF"><span class="RefLink">61.2-1</span></a>) returns vector spaces etc.:</p>

<p><code class="code"><var class="Arg">Struct</var>( <var class="Arg">arg1</var>, <var class="Arg">arg2</var>, ... )</code></p>

<p>The syntax of these functions may vary, dependent on the structure in question. Usually a domain is constructed as the closure of some elements under the given operations, that is, the domain is given by its <em>generators</em>. For example, a group can be constructed from a list of generating permutations or matrices or whatever is admissible as group elements, and a vector space over a given field <span class="SimpleMath">F</span> can be constructed from <span class="SimpleMath">F</span> and a list of appropriate vectors.</p>

<p>The idea of generation and generators in <strong class="pkg">GAP</strong> is that the domain returned by a function such as <code class="code">Group</code>, <code class="code">Algebra</code>, or <code class="code">FreeLeftModule</code> <em>contains</em> the given generators. This implies that the generators of a group must know how they are multiplied and inverted, the generators of a module must know how they are added and how scalar multiplication works, and so on. Thus one cannot use for example permutations as generators of a vector space.</p>

<p>The function <var class="Arg">Struct</var> first checks whether the arguments admit the construction of a domain with the desired structure. This is done by calling the operation</p>

<p><code class="code">IsGeneratorsOf<var class="Arg">Struct</var>( [<var class="Arg">info</var>, ]<var class="Arg">gens</var> )</code></p>

<p>where <var class="Arg">arglist</var> is the list of given generators and <var class="Arg">info</var> an argument of <var class="Arg">Struct</var>, for example the field of scalars in the case that a vector space shall be constructed. If the check failed then <var class="Arg">Struct</var> returns <code class="keyw">fail</code>, otherwise it returns the result of <code class="code"><var class="Arg">Struct</var>ByGenerators</code> (see below). (So if one wants to omit the check then one should call <code class="code"><var class="Arg">Struct</var>ByGenerators</code> directly.)</p>

<p><code class="code">GeneratorsOf<var class="Arg">Struct</var>( <var class="Arg">D</var>)</code></p>

<p>For a domain <var class="Arg">D</var> with operational structure corresponding to <var class="Arg">Struct</var>, the attribute <code class="code">GeneratorsOf<var class="Arg">Struct</var></code> returns a list of corresponding generators of <var class="Arg">D</var>. If these generators were not yet stored in <var class="Arg">D</var> then <var class="Arg">D</var> must know <em>some</em> generators if <code class="code">GeneratorsOf<var class="Arg">Struct</var></code> shall have a chance to compute the desired result; for example, monoid generators of a group can be computed from known group generators (and vice versa). Note that several notions of generation may be meaningful for a given domain, so it makes no sense to ask for "the generators of a domain". Further note that the generators may depend on other information about <var class="Arg">D</var>. For example the generators of a vector space depend on the underlying field of scalars; the vector space generators of a vector space over the field with four elements need not generate the same vector space when this is viewed as a space over the field with two elements.</p>

<p><code class="code"><var class="Arg">Struct</var>ByGenerators( [<var class="Arg">info</var>, ]<var class="Arg">gens</var> )</code></p>

<p>Domain construction from generators <var class="Arg">gens</var> is implemented by operations <code class="code"><var class="Arg">Struct</var>ByGenerators</code>, which are called by the simple functions <var class="Arg">Struct</var>; methods can be installed only for the operations. Note that additional information <var class="Arg">info</var> may be necessary to construct the domain; for example, a vector space needs the underlying field of scalars in addition to the list of vector space generators. The <code class="code">GeneratorsOf<var class="Arg">Struct</var></code> value of the returned domain need <em>not</em> be equal to <var class="Arg">gens</var>. But if a domain <var class="Arg">D</var> is printed as <code class="code"><var class="Arg">Struct</var>([<var class="Arg">a</var>, <var class="Arg">b</var>, ...])</code> and if there is an attribute <code class="code">GeneratorsOf<var class="Arg">Struct</var></code> then the list <code class="code">GeneratorsOf<var class="Arg">Struct</var>( <var class="Arg">D</var> )</code> is guaranteed to be equal to <code class="code">[ <var class="Arg">a</var>, <var class="Arg">b</var>, ... ]</code>.</p>

<p><code class="code"><var class="Arg">Struct</var>WithGenerators( [<var class="Arg">info</var>, ]<var class="Arg">gens</var> )</code></p>

<p>The only difference between <code class="code"><var class="Arg">Struct</var>ByGenerators</code> and <code class="code"><var class="Arg">Struct</var>WithGenerators</code> is that the latter guarantees that the <code class="code">GeneratorsOf<var class="Arg">Struct</var></code> value of the result is equal to the given generators <var class="Arg">gens</var>.</p>

<p><code class="code">Closure<var class="Arg">Struct</var>( <var class="Arg">D</var>, <var class="Arg">obj</var> )</code></p>

<p>For constructing a domain as the closure of a given domain with an element or another domain, one can use the operation <code class="code">Closure<var class="Arg">Struct</var></code>. It returns the smallest domain with operational structure corresponding to <var class="Arg">Struct</var> that contains <var class="Arg">D</var> as a subset and <var class="Arg">obj</var> as an element.</p>

<p><a id="X7EA77DE17DD8A231" name="X7EA77DE17DD8A231"></a></p>

<h4>31.4 <span class="Heading">Changing the Structure</span></h4>

<p>The same set of elements can have different operational structures. For example, it may happen that a monoid <span class="SimpleMath">M</span> does in fact contain the inverses of all of its elements; if <span class="SimpleMath">M</span> has not been constructed as a group (see <a href="chap31.html#X7D72F11B82F4A036"><span class="RefLink">31.6</span></a>) then it is reasonable to ask for the group that is equal to <span class="SimpleMath">M</span>.</p>

<p><code class="code">As<var class="Arg">Struct</var>( [<var class="Arg">info</var>, ]<var class="Arg">D</var> )</code></p>

<p>If <var class="Arg">D</var> is a domain that is closed under the operational structure given by <var class="Arg">Struct</var> then <code class="code">As<var class="Arg">Struct</var></code> returns a domain <var class="Arg">E</var> that consists of the same elements (that is, <code class="code"><var class="Arg">D</var> = <var class="Arg">E</var></code>) and that has this operational structure (that is, <code class="code">Is<var class="Arg">Struct</var>( <var class="Arg">E</var> )</code> is <code class="keyw">true</code>); if <var class="Arg">D</var> is not closed under the structure given by <var class="Arg">Struct</var> then <code class="code">As<var class="Arg">Struct</var></code> returns <code class="keyw">fail</code>.</p>

<p>If additional information besides generators are necessary to define <var class="Arg">D</var> then the argument <var class="Arg">info</var> describes the value of this information for the desired domain. For example, if we want to view <var class="Arg">D</var> as a vector space over the field with two elements then we may call <code class="code">AsVectorSpace( GF(2), <var class="Arg">D</var> )</code>; this allows us to change the underlying field of scalars, for example if <var class="Arg">D</var> is a vector space over the field with four elements. Again, if <var class="Arg">D</var> is not equal to a domain with the desired structure and additional information then <code class="keyw">fail</code> is returned.</p>

<p>In the case that no additional information <var class="Arg">info</var> is related to the structure given by <var class="Arg">Struct</var>, the operation <code class="code">As<var class="Arg">Struct</var></code> is in fact an attribute (see <a href="chap13.html#X7C701DBF7BAE649A"><span class="RefLink">13.5</span></a>).</p>

<p>See the index of the <strong class="pkg">GAP</strong> Reference Manual for an overview of the available <code class="code">As<var class="Arg">Struct</var></code> functions.</p>

<p><a id="X860FCCBE7A41412F" name="X860FCCBE7A41412F"></a></p>

<h4>31.5 <span class="Heading">Changing the Representation</span></h4>

<p>Often it is useful to answer questions about a domain via computations in a different but isomorphic domain. In the sense that this approach keeps the structure and changes the underlying set of elements, it can be viewed as a counterpart of keeping the set of elements and changing its structure (see <a href="chap31.html#X7EA77DE17DD8A231"><span class="RefLink">31.4</span></a>).</p>

<p>One reason for doing so can be that computations with the elements in the given domain are not very efficient. For example, if one is given a solvable matrix group (see Chapter <a href="chap44.html#X7CF51CB48610A07D"><span class="RefLink">44</span></a>) then one can compute an isomorphism to a polycyclicly presented group <span class="SimpleMath">G</span>, say (see Chapter <a href="chap45.html#X86007B0083F60470"><span class="RefLink">45</span></a>); the multiplication of two matrices –which is essentially determined by the dimension of the matrices– is much more expensive than the multiplication of two elements in <span class="SimpleMath">G</span> –which is essentially determined by the composition length of <span class="SimpleMath">G</span>.</p>

<p><code class="code">Isomorphism<var class="Arg">Rep</var><var class="Arg">Struct</var>( <var class="Arg">D</var> )</code></p>

<p>If <var class="Arg">D</var> is a domain that is closed under the operational structure given by <var class="Arg">Struct</var> then <code class="code">Isomorphism<var class="Arg">Rep</var><var class="Arg">Struct</var></code> returns a mapping <var class="Arg">hom</var> from <var class="Arg">D</var> to a domain <span class="SimpleMath">E</span> having structure given by <var class="Arg">Struct</var>, such that <var class="Arg">hom</var> respects the structure <var class="Arg">Struct</var> and <var class="Arg">Rep</var> describes the representation of the elements in <span class="SimpleMath">E</span>. If no domain <span class="SimpleMath">E</span> with the required properties exists then <code class="keyw">fail</code> is returned.</p>

<p>For example, <code class="func">IsomorphismPermGroup</code> (<a href="chap43.html#X80B7B1C783AA1567"><span class="RefLink">43.3-1</span></a>) takes a group as its argument and returns a group homomorphism (see <a href="chap40.html#X83702FC27B3C3098"><span class="RefLink">40</span></a>) onto an isomorphic permutation group (see Chapter <a href="chap43.html#X85ED46007CED6191"><span class="RefLink">43</span></a>) provided the original group is finite; for infinite groups, <code class="func">IsomorphismPermGroup</code> (<a href="chap43.html#X80B7B1C783AA1567"><span class="RefLink">43.3-1</span></a>) returns <code class="keyw">fail</code>. Similarly, <code class="func">IsomorphismPcGroup</code> (<a href="chap46.html#X873CEB137BA1CD6E"><span class="RefLink">46.5-2</span></a>) returns a group homomorphism from its argument to a polycyclicly presented group (see <a href="chap46.html#X7EAD57C97EBF7E67"><span class="RefLink">46</span></a>) if the argument is polycyclic, and <code class="keyw">fail</code> otherwise.</p>

<p>See the index of the <strong class="pkg">GAP</strong> Reference Manual for an overview of the available <code class="code">Isomorphism<var class="Arg">Rep</var><var class="Arg">Struct</var></code> functions.</p>

<p><a id="X7D72F11B82F4A036" name="X7D72F11B82F4A036"></a></p>

<h4>31.6 <span class="Heading">Domain Categories</span></h4>

<p>As mentioned in <a href="chap31.html#X859C7AB97B34F55F"><span class="RefLink">31.1</span></a>, the operational structure of a domain is fixed when the domain is constructed. For example, if <var class="Arg">D</var> was constructed by <code class="func">Monoid</code> (<a href="chap51.html#X7F95328B7C7E49EA"><span class="RefLink">51.2-2</span></a>) then <var class="Arg">D</var> is in general not regarded as a group in <strong class="pkg">GAP</strong>, even if <var class="Arg">D</var> is in fact closed under taking inverses. In this case, <code class="func">IsGroup</code> (<a href="chap39.html#X7939B3177BBD61E4"><span class="RefLink">39.2-7</span></a>) returns <code class="keyw">false</code> for <var class="Arg">D</var>. The operational structure determines which operations are applicable for a domain, so for example <code class="func">SylowSubgroup</code> (<a href="chap39.html#X7AA351308787544C"><span class="RefLink">39.13-1</span></a>) is not defined for <var class="Arg">D</var> and therefore will signal an error.</p>

<p><code class="code">Is<var class="Arg">Struct</var>( <var class="Arg">D</var> )</code></p>

<p>The functions <code class="code">Is<var class="Arg">Struct</var></code> implement the tests whether a domain <var class="Arg">D</var> has the respective operational structure (upon construction). <code class="code">Is<var class="Arg">Struct</var></code> is a filter (see <a href="chap13.html#X7E8202627B421DB1"><span class="RefLink">13</span></a>) that involves certain categories (see <a href="chap13.html#X7CC6903E78F24167"><span class="RefLink">13.3</span></a>) and usually also certain properties (see <a href="chap13.html#X871597447BB998A1"><span class="RefLink">13.7</span></a>). For example, <code class="func">IsGroup</code> (<a href="chap39.html#X7939B3177BBD61E4"><span class="RefLink">39.2-7</span></a>) is equivalent to <code class="code">IsMagmaWithInverses and IsAssociative</code>, the first being a category and the second being a property.</p>

<p>Implications between domain categories describe the hierarchy of operational structures available in <strong class="pkg">GAP</strong>. Here are some typical examples.</p>


<ul>
<li><p><code class="func">IsDomain</code> (<a href="chap31.html#X86B4AC017FAF4D12"><span class="RefLink">31.9-1</span></a>) is implied by each domain category,</p>

</li>
<li><p><code class="func">IsMagma</code> (<a href="chap35.html#X87D3F38B7EAB13FA"><span class="RefLink">35.1-1</span></a>) is implied by each category that describes the closure under multiplication <code class="code">*</code>,</p>

</li>
<li><p><code class="func">IsAdditiveMagma</code> (<a href="chap55.html#X8565FD0C847BAA3A"><span class="RefLink">55.1-4</span></a>) is implied by each category that describes the closure under addition <code class="code">+</code>,</p>

</li>
<li><p><code class="func">IsMagmaWithOne</code> (<a href="chap35.html#X86071DE7835F1C7C"><span class="RefLink">35.1-2</span></a>) implies <code class="func">IsMagma</code> (<a href="chap35.html#X87D3F38B7EAB13FA"><span class="RefLink">35.1-1</span></a>); a <em>magma-with-one</em> is a magma such that each element (and thus also the magma itself) can be asked for its zeroth power,</p>

</li>
<li><p><code class="func">IsMagmaWithInverses</code> (<a href="chap35.html#X82CBFF648574B830"><span class="RefLink">35.1-4</span></a>) implies <code class="func">IsMagmaWithOne</code> (<a href="chap35.html#X86071DE7835F1C7C"><span class="RefLink">35.1-2</span></a>); a <em>magma-with-inverses</em> is a magma such that each element can be asked for its inverse; important special cases are <em>groups</em>, which in addition are associative,</p>

</li>
<li><p>a <em>ring</em> is a magma that is also an additive group,</p>

</li>
<li><p>a <em>ring-with-one</em> is a ring that is also a magma-with-one,</p>

</li>
<li><p>a <em>division ring</em> is a ring-with-one that is also closed under taking inverses of nonzero elements,</p>

</li>
<li><p>a <em>field</em> is a commutative division ring.</p>

</li>
</ul>
<p>Each operational structure <var class="Arg">Struct</var> has associated with it a domain category <code class="code">Is<var class="Arg">Struct</var></code>, and operations <code class="code"><var class="Arg">Struct</var>ByGenerators</code> for constructing a domain from generators, <code class="code">GeneratorsOf<var class="Arg">Struct</var></code> for storing and accessing generators w.r.t. this structure, <code class="code">Closure<var class="Arg">Struct</var></code> for forming the closure, and <code class="code">As<var class="Arg">Struct</var></code> for getting a domain with the desired structure from one with weaker operational structure and for testing whether a given domain can be regarded as a domain with <var class="Arg">Struct</var>.</p>

<p>The functions applicable to domains with the various structures are described in the corresponding chapters of the Reference Manual. For example, functions for rings, fields, groups, and vector spaces are described in Chapters <a href="chap56.html#X81897F6082CACB59"><span class="RefLink">56</span></a>, <a href="chap58.html#X80A8E676814A19FD"><span class="RefLink">58</span></a>, <a href="chap39.html#X8716635F7951801B"><span class="RefLink">39</span></a>, and <a href="chap61.html#X7DAD6700787EC845"><span class="RefLink">61</span></a>, respectively. More general functions for arbitrary collections can be found in Chapter <a href="chap30.html#X8050A8037984E5B6"><span class="RefLink">30</span></a>.</p>

<p><a id="X7CBDD36E7B7BE286" name="X7CBDD36E7B7BE286"></a></p>

<h4>31.7 <span class="Heading">Parents</span></h4>

<p><a id="X7BC856CC7F116BB0" name="X7BC856CC7F116BB0"></a></p>

<h5>31.7-1 Parent</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Parent</code>( <var class="Arg">D</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; SetParent</code>( <var class="Arg">D</var>, <var class="Arg">P</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; HasParent</code>( <var class="Arg">D</var> )</td><td class="tdright">(&nbsp;filter&nbsp;)</td></tr></table></div>
<p>It is possible to assign to a domain <var class="Arg">D</var> one other domain <var class="Arg">P</var> containing <var class="Arg">D</var> as a subset, in order to exploit this subset relation between <var class="Arg">D</var> and <var class="Arg">P</var>. Note that <var class="Arg">P</var> need not have the same operational structure as <var class="Arg">D</var>, for example <var class="Arg">P</var> may be a magma and <var class="Arg">D</var> a field.</p>

<p>The assignment is done by calling <code class="func">SetParent</code>, and <var class="Arg">P</var> is called the <em>parent</em> of <var class="Arg">D</var>. If <var class="Arg">D</var> has already a parent, calls to <code class="func">SetParent</code> will be ignored.</p>

<p>If <var class="Arg">D</var> has a parent <var class="Arg">P</var> –this can be checked with <code class="func">HasParent</code>– then <var class="Arg">P</var> can be used to gain information about <var class="Arg">D</var>. First, the call of <code class="func">SetParent</code> causes <code class="func">UseSubsetRelation</code> (<a href="chap31.html#X7C03098C838ADE40"><span class="RefLink">31.13-1</span></a>) to be called. Second, for a domain <var class="Arg">D</var> with parent, information relative to the parent can be stored in <var class="Arg">D</var>; for example, there is an attribute <code class="code">NormalizerInParent</code> for storing <code class="code">Normalizer( <var class="Arg">P</var>, <var class="Arg">D</var> )</code> in the case that <var class="Arg">D</var> is a group. (More about such parent dependent attributes can be found in <a href="chap85.html#X78D4D0FF780C8A85"><span class="RefLink">85.2</span></a>.) Note that because of this relative information, one cannot change the parent; that is, one can set the parent only once, subsequent calls to <code class="func">SetParent</code> for the same domain <var class="Arg">D</var> are ignored. Further note that contrary to <code class="func">UseSubsetRelation</code> (<a href="chap31.html#X7C03098C838ADE40"><span class="RefLink">31.13-1</span></a>), also knowledge about the parent <var class="Arg">P</var> might be used that is discovered after the <code class="func">SetParent</code> call.</p>

<p>A stored parent can be accessed using <code class="func">Parent</code>. If <var class="Arg">D</var> has no parent then <code class="func">Parent</code> returns <var class="Arg">D</var> itself, and <code class="func">HasParent</code> will return <code class="keyw">false</code> also after a call to <code class="func">Parent</code>. So <code class="func">Parent</code> is <em>not</em> an attribute, the underlying attribute to store the parent is <code class="code">ParentAttr</code>.</p>

<p>Certain functions that return domains with parent already set, for example <code class="func">Subgroup</code> (<a href="chap39.html#X7C82AA387A42DCA0"><span class="RefLink">39.3-1</span></a>), are described in Section <a href="chap31.html#X7B58FDEF80338DD6"><span class="RefLink">31.8</span></a>. Whenever a function has this property, the <strong class="pkg">GAP</strong> Reference Manual states this explicitly. Note that these functions <em>do not guarantee</em> a certain parent, for example <code class="func">DerivedSubgroup</code> (<a href="chap39.html#X7CC17CF179ED7EF2"><span class="RefLink">39.12-3</span></a>) for a perfect group <span class="SimpleMath">G</span> may return <span class="SimpleMath">G</span> itself, and if <span class="SimpleMath">G</span> had already a parent then this is not replaced by <span class="SimpleMath">G</span>. As a rule of thumb, <strong class="pkg">GAP</strong> avoids to set a domain as its own parent, which is consistent with the behaviour of <code class="func">Parent</code>, at least until a parent is set explicitly with <code class="func">SetParent</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g:= Group( (1,2,3), (1,2) );; h:= Group( (1,2) );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">HasParent( g );  HasParent( h );</span>
false
false
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetParent( h, g );</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Parent( g );  Parent( h );</span>
Group([ (1,2,3), (1,2) ])
Group([ (1,2,3), (1,2) ])
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">HasParent( g );  HasParent( h );</span>
false
true
</pre></div>

<p><a id="X7B58FDEF80338DD6" name="X7B58FDEF80338DD6"></a></p>

<h4>31.8 <span class="Heading">Constructing Subdomains</span></h4>

<p>For many domains <var class="Arg">D</var>, there are functions that construct certain subsets <var class="Arg">S</var> of <var class="Arg">D</var> as domains with parent (see <a href="chap31.html#X7CBDD36E7B7BE286"><span class="RefLink">31.7</span></a>) already set to <var class="Arg">D</var>. For example, if <var class="Arg">G</var> is a group that contains the elements in the list <var class="Arg">gens</var> then <code class="code">Subgroup( <var class="Arg">G</var>, <var class="Arg">gens</var> )</code> returns a group <var class="Arg">S</var> that is generated by the elements in <var class="Arg">gens</var> and with <code class="code">Parent( <var class="Arg">S</var> ) = <var class="Arg">G</var></code>.</p>

<p><code class="code">Sub<var class="Arg">struct</var>( <var class="Arg">D</var>, <var class="Arg">gens</var> )</code></p>

<p>More general, if <var class="Arg">D</var> is a domain whose algebraic structure is given by the function <var class="Arg">Struct</var> (for example <code class="code">Group</code>, <code class="code">Algebra</code>, <code class="code">Field</code>) then the function <code class="code">Sub<var class="Arg">struct</var></code> (for example <code class="code">Subgroup</code>, <code class="code">Subalgebra</code>, <code class="code">Subfield</code>) returns domains with structure <var class="Arg">Struct</var> and parent set to the first argument.</p>

<p><code class="code">Sub<var class="Arg">struct</var>NC( <var class="Arg">D</var>, <var class="Arg">gens</var> )</code></p>

<p>Each function <code class="code">Sub<var class="Arg">struct</var></code> checks that the <var class="Arg">Struct</var> generated by <var class="Arg">gens</var> is in fact a subset of <var class="Arg">D</var>. If one wants to omit this check then one can call <code class="code">Sub<var class="Arg">struct</var>NC</code> instead; the suffix <code class="code">NC</code> stands for "no check".</p>

<p><code class="code">AsSub<var class="Arg">struct</var>( <var class="Arg">D</var>, <var class="Arg">S</var> )</code></p>

<p>first constructs <code class="code">As<var class="Arg">Struct</var>( [<var class="Arg">info</var>, ]<var class="Arg">S</var> )</code>, where <var class="Arg">info</var> depends on <var class="Arg">D</var> and <var class="Arg">S</var>, and then sets the parent (see <a href="chap31.html#X7CBDD36E7B7BE286"><span class="RefLink">31.7</span></a>) of this new domain to <var class="Arg">D</var>.</p>

<p><code class="code">IsSub<var class="Arg">struct</var>( <var class="Arg">D</var>, <var class="Arg">S</var> )</code></p>

<p>There is no real need for functions that check whether a domain <var class="Arg">S</var> is a <code class="code">Sub<var class="Arg">struct</var></code> of a domain <var class="Arg">D</var>, since this is equivalent to the checks whether <var class="Arg">S</var> is a <var class="Arg">Struct</var> and <var class="Arg">S</var> is a subset of <var class="Arg">D</var>. Note that in many cases, only the subset relation is what one really wants to check, and that appropriate methods for the operation <code class="func">IsSubset</code> (<a href="chap30.html#X79CA175481F8105F"><span class="RefLink">30.5-1</span></a>) are available for many special situations, such as the test whether a group is contained in another group, where only generators need to be checked.</p>

<p>If a function <code class="code">IsSub<var class="Arg">struct</var></code> is available in <strong class="pkg">GAP</strong> then it is implemented as first a call to <code class="code">Is<var class="Arg">Struct</var></code> for the second argument and then a call to <code class="func">IsSubset</code> (<a href="chap30.html#X79CA175481F8105F"><span class="RefLink">30.5-1</span></a>) for the two arguments.</p>

<p><a id="X86D579707B112970" name="X86D579707B112970"></a></p>

<h4>31.9 <span class="Heading">Operations for Domains</span></h4>

<p>For the meaning of the attributes <code class="func">Characteristic</code> (<a href="chap31.html#X81278E53800BF64D"><span class="RefLink">31.10-1</span></a>), <code class="func">One</code> (<a href="chap31.html#X8046262384895B2A"><span class="RefLink">31.10-2</span></a>), <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442"><span class="RefLink">31.10-3</span></a>) in the case of a domain argument, see <a href="chap31.html#X7C2B0C1280237CB0"><span class="RefLink">31.10</span></a>.</p>

<p><a id="X86B4AC017FAF4D12" name="X86B4AC017FAF4D12"></a></p>

<h5>31.9-1 IsGeneralizedDomain</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsGeneralizedDomain</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsDomain</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>For some purposes, it is useful to deal with objects that are similar to domains but that are not collections in the sense of <strong class="pkg">GAP</strong> because their elements may lie in different families; such objects are called <em>generalized domains</em>. An instance of generalized domains are "operation domains", for example any <span class="SimpleMath">G</span>-set for a permutation group <span class="SimpleMath">G</span> consisting of some union of points, sets of points, sets of sets of points etc., under a suitable action.</p>

<p><code class="func">IsDomain</code> is a synonym for <code class="code">IsGeneralizedDomain and IsCollection</code>.</p>

<p><a id="X7E353DD1838AB223" name="X7E353DD1838AB223"></a></p>

<h5>31.9-2 GeneratorsOfDomain</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; GeneratorsOfDomain</code>( <var class="Arg">D</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<p>For a domain <var class="Arg">D</var>, <code class="func">GeneratorsOfDomain</code> returns a list containing all elements of <var class="Arg">D</var>, perhaps with repetitions. Note that if the domain <var class="Arg">D</var> shall be generated by a list of some elements w.r.t. the empty operational structure (see <a href="chap31.html#X859C7AB97B34F55F"><span class="RefLink">31.1</span></a>), the only possible choice of elements is to take all elements of <var class="Arg">D</var>. See <a href="chap31.html#X82039A218274826F"><span class="RefLink">31.3</span></a> and <a href="chap31.html#X7EA77DE17DD8A231"><span class="RefLink">31.4</span></a> for concepts of other notions of generation.</p>

<p>For many domains that have <em>natural generators by construction</em> (for example, the natural generators of a free group of rank two are the two generators stored as value of the attribute <code class="func">GeneratorsOfGroup</code> (<a href="chap39.html#X79C44528864044C5"><span class="RefLink">39.2-4</span></a>), and the natural generators of a free associative algebra are those generators stored as value of the attribute <code class="func">GeneratorsOfAlgebra</code> (<a href="chap62.html#X83B055F37EBF2438"><span class="RefLink">62.9-1</span></a>)), each <em>natural</em> generator can be accessed using the <code class="code">.</code> operator. For a domain <var class="Arg">D</var>, <code class="code"><var class="Arg">D</var>.i</code> returns the <span class="SimpleMath">i</span>-th generator if <span class="SimpleMath">i</span> is a positive integer, and if <code class="code">name</code> is the name of a generator of <var class="Arg">D</var> then <code class="code"><var class="Arg">D</var>.name</code> returns this generator.</p>

<p><a id="X826A21287FD3ACC0" name="X826A21287FD3ACC0"></a></p>

<h5>31.9-3 Domain</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Domain</code>( [<var class="Arg">Fam</var>, ]<var class="Arg">generators</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; DomainByGenerators</code>( <var class="Arg">Fam</var>, <var class="Arg">generators</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p><code class="func">Domain</code> returns the domain consisting of the elements in the homogeneous list <var class="Arg">generators</var>. If <var class="Arg">generators</var> is empty then a family <var class="Arg">Fam</var> must be entered as the first argument, and the returned (empty) domain lies in the collections family of <var class="Arg">Fam</var>.</p>

<p><code class="func">DomainByGenerators</code> is the operation called by <code class="func">Domain</code>.</p>

<p><a id="X7C2B0C1280237CB0" name="X7C2B0C1280237CB0"></a></p>

<h4>31.10 <span class="Heading">Attributes and Properties of Elements</span></h4>

<p>The following attributes and properties for elements and domains correspond to the operational structure.</p>

<p><a id="X81278E53800BF64D" name="X81278E53800BF64D"></a></p>

<h5>31.10-1 Characteristic</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Characteristic</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<p><code class="func">Characteristic</code> returns the <em>characteristic</em> of <var class="Arg">obj</var>.</p>

<p>If <var class="Arg">obj</var> is a family, all of whose elements lie in <code class="func">IsAdditiveElementWithZero</code> (<a href="chap31.html#X87F3552A789C572D"><span class="RefLink">31.14-5</span></a>) then its characteristic is the least positive integer <span class="SimpleMath">n</span>, if any, such that <code class="code">IsZero(n*x)</code> is <code class="keyw">true</code> for all <code class="code">x</code> in the family <var class="Arg">obj</var>, otherwise it is <span class="SimpleMath">0</span>.</p>

<p>If <var class="Arg">obj</var> is a collections family of a family <span class="SimpleMath">g</span> which has a characteristic, then the characteristic of <var class="Arg">obj</var> is the same as the characteristic of <span class="SimpleMath">g</span>.</p>

<p>For other families <var class="Arg">obj</var> the characteristic is not defined and <code class="keyw">fail</code> will be returned.</p>

<p>For any object <var class="Arg">obj</var> which is in the filter <code class="func">IsAdditiveElementWithZero</code> (<a href="chap31.html#X87F3552A789C572D"><span class="RefLink">31.14-5</span></a>) or in the filter <code class="func">IsAdditiveMagmaWithZero</code> (<a href="chap55.html#X785B41A67D791783"><span class="RefLink">55.1-5</span></a>) the characteristic of <var class="Arg">obj</var> is the same as the characteristic of its family if that is defined and undefined otherwise.</p>

<p>For all other objects <var class="Arg">obj</var> the characteristic is undefined and may return <code class="keyw">fail</code> or a "no method found" error.</p>

<p><a id="X8046262384895B2A" name="X8046262384895B2A"></a></p>

<h5>31.10-2 OneImmutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OneImmutable</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OneAttr</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; One</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Identity</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OneMutable</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OneOp</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OneSameMutability</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OneSM</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p><code class="func">OneImmutable</code>, <code class="func">OneMutable</code>, and <code class="func">OneSameMutability</code> return the multiplicative neutral element of the multiplicative element <var class="Arg">obj</var>.</p>

<p>They differ only w.r.t. the mutability of the result. <code class="func">OneImmutable</code> is an attribute and hence returns an immutable result. <code class="func">OneMutable</code> is guaranteed to return a new <em>mutable</em> object whenever a mutable version of the required element exists in <strong class="pkg">GAP</strong> (see <code class="func">IsCopyable</code> (<a href="chap12.html#X811EFD727EBD1ADC"><span class="RefLink">12.6-1</span></a>)). <code class="func">OneSameMutability</code> returns a result that is mutable if <var class="Arg">obj</var> is mutable and if a mutable version of the required element exists in <strong class="pkg">GAP</strong>; for lists, it returns a result of the same immutability level as the argument. For instance, if the argument is a mutable matrix with immutable rows, it returns a similar object.</p>

<p>If <var class="Arg">obj</var> is a multiplicative element then <code class="code">OneSameMutability( <var class="Arg">obj</var> )</code> is equivalent to <code class="code"><var class="Arg">obj</var>^0</code>.</p>

<p><code class="func">OneAttr</code>, <code class="func">One</code> and <code class="func">Identity</code> are synonyms of <code class="code">OneImmutable</code>. <code class="func">OneSM</code> is a synonym of <code class="func">OneSameMutability</code>. <code class="func">OneOp</code> is a synonym of <code class="func">OneMutable</code>.</p>

<p>If <var class="Arg">obj</var> is a domain or a family then <code class="func">One</code> is defined as the identity element of all elements in <var class="Arg">obj</var>, provided that all these elements have the same identity. For example, the family of all cyclotomics has the identity element <code class="code">1</code>, but a collections family (see <code class="func">CollectionsFamily</code> (<a href="chap30.html#X84E5A67E87D8DD66"><span class="RefLink">30.2-1</span></a>)) may contain matrices of all dimensions and then it cannot have a unique identity element. Note that <code class="func">One</code> is applicable to a domain only if it is a magma-with-one (see <code class="func">IsMagmaWithOne</code> (<a href="chap35.html#X86071DE7835F1C7C"><span class="RefLink">35.1-2</span></a>)); use <code class="func">MultiplicativeNeutralElement</code> (<a href="chap35.html#X7EE2EA5F7EB7FEC2"><span class="RefLink">35.4-10</span></a>) otherwise.</p>

<p>The identity of an object need not be distinct from its zero, so for example a ring consisting of a single element can be regarded as a ring-with-one (see <a href="chap56.html#X81897F6082CACB59"><span class="RefLink">56</span></a>). This is particularly useful in the case of finitely presented algebras, where any factor of a free algebra-with-one is again an algebra-with-one, no matter whether or not it is a zero algebra.</p>

<p>The default method of <code class="func">One</code> for multiplicative elements calls <code class="func">OneMutable</code> (note that methods for <code class="func">OneMutable</code> must <em>not</em> delegate to <code class="func">One</code>); so other methods to compute identity elements need to be installed only for <code class="func">OneOp</code> and (in the case of copyable objects) <code class="func">OneSameMutability</code>.</p>

<p>For domains, <code class="func">One</code> may call <code class="func">Representative</code> (<a href="chap30.html#X865507568182424E"><span class="RefLink">30.4-7</span></a>), but <code class="func">Representative</code> (<a href="chap30.html#X865507568182424E"><span class="RefLink">30.4-7</span></a>) is allowed to fetch the identity of a domain <var class="Arg">D</var> only if <code class="code">HasOne( <var class="Arg">D</var> )</code> is <code class="keyw">true</code>.</p>

<p><a id="X8040AC7A79FFC442" name="X8040AC7A79FFC442"></a></p>

<h5>31.10-3 ZeroImmutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ZeroImmutable</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ZeroAttr</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Zero</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ZeroMutable</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ZeroOp</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ZeroSameMutability</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ZeroSM</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p><code class="func">ZeroImmutable</code>, <code class="func">ZeroMutable</code>, and <code class="func">ZeroSameMutability</code> all return the additive neutral element of the additive element <var class="Arg">obj</var>.</p>

<p>They differ only w.r.t. the mutability of the result. <code class="func">ZeroImmutable</code> is an attribute and hence returns an immutable result. <code class="func">ZeroMutable</code> is guaranteed to return a new <em>mutable</em> object whenever a mutable version of the required element exists in <strong class="pkg">GAP</strong> (see <code class="func">IsCopyable</code> (<a href="chap12.html#X811EFD727EBD1ADC"><span class="RefLink">12.6-1</span></a>)). <code class="func">ZeroSameMutability</code> returns a result that is mutable if <var class="Arg">obj</var> is mutable and if a mutable version of the required element exists in <strong class="pkg">GAP</strong>; for lists, it returns a result of the same immutability level as the argument. For instance, if the argument is a mutable matrix with immutable rows, it returns a similar object.</p>

<p><code class="code">ZeroSameMutability( <var class="Arg">obj</var> )</code> is equivalent to <code class="code">0 * <var class="Arg">obj</var></code>.</p>

<p><code class="func">ZeroAttr</code> and <code class="func">Zero</code> are synonyms of <code class="func">ZeroImmutable</code>. <code class="func">ZeroSM</code> is a synonym of <code class="func">ZeroSameMutability</code>. <code class="func">ZeroOp</code> is a synonym of <code class="func">ZeroMutable</code>.</p>

<p>If <var class="Arg">obj</var> is a domain or a family then <code class="func">Zero</code> is defined as the zero element of all elements in <var class="Arg">obj</var>, provided that all these elements have the same zero. For example, the family of all cyclotomics has the zero element <code class="code">0</code>, but a collections family (see <code class="func">CollectionsFamily</code> (<a href="chap30.html#X84E5A67E87D8DD66"><span class="RefLink">30.2-1</span></a>)) may contain matrices of all dimensions and then it cannot have a unique zero element. Note that <code class="func">Zero</code> is applicable to a domain only if it is an additive magma-with-zero (see <code class="func">IsAdditiveMagmaWithZero</code> (<a href="chap55.html#X785B41A67D791783"><span class="RefLink">55.1-5</span></a>)); use <code class="func">AdditiveNeutralElement</code> (<a href="chap55.html#X851EA2E67F0C9A75"><span class="RefLink">55.3-5</span></a>) otherwise.</p>

<p>The default method of <code class="func">Zero</code> for additive elements calls <code class="func">ZeroMutable</code> (note that methods for <code class="func">ZeroMutable</code> must <em>not</em> delegate to <code class="func">Zero</code>); so other methods to compute zero elements need to be installed only for <code class="func">ZeroMutable</code> and (in the case of copyable objects) <code class="func">ZeroSameMutability</code>.</p>

<p>For domains, <code class="func">Zero</code> may call <code class="func">Representative</code> (<a href="chap30.html#X865507568182424E"><span class="RefLink">30.4-7</span></a>), but <code class="func">Representative</code> (<a href="chap30.html#X865507568182424E"><span class="RefLink">30.4-7</span></a>) is allowed to fetch the zero of a domain <var class="Arg">D</var> only if <code class="code">HasZero( <var class="Arg">D</var> )</code> is <code class="keyw">true</code>.</p>

<p><a id="X86DEB543824C40EB" name="X86DEB543824C40EB"></a></p>

<h5>31.10-4 MultiplicativeZeroOp</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; MultiplicativeZeroOp</code>( <var class="Arg">elt</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>Returns: A multiplicative zero element.</p>

<p>for an element <var class="Arg">elt</var> in the category <code class="func">IsMultiplicativeElementWithZero</code> (<a href="chap31.html#X8703BFC2841BBD63"><span class="RefLink">31.14-12</span></a>), <code class="code">MultiplicativeZeroOp</code> returns the element <span class="SimpleMath">z</span> in the family <span class="SimpleMath">F</span> of <var class="Arg">elt</var> with the property that <span class="SimpleMath">z * m = z = m * z</span> holds for all <span class="SimpleMath">m ∈ F</span>, if such an element can be determined.</p>

<p>Families of elements in the category <code class="func">IsMultiplicativeElementWithZero</code> (<a href="chap31.html#X8703BFC2841BBD63"><span class="RefLink">31.14-12</span></a>) often arise from adjoining a new zero to an existing magma. See <code class="func">InjectionZeroMagma</code> (<a href="chap35.html#X8620878D7FD98823"><span class="RefLink">35.2-13</span></a>) or <code class="func">MagmaWithZeroAdjoined</code> (<a href="chap35.html#X8620878D7FD98823"><span class="RefLink">35.2-13</span></a>) for details.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G:=AlternatingGroup(5);;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">x:=Representative(MagmaWithZeroAdjoined(G));</span>
&lt;group with 0 adjoined elt: ()&gt;
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">MultiplicativeZeroOp(x);</span>
&lt;group with 0 adjoined elt: 0&gt;
</pre></div>

<p><a id="X814D78347858EC13" name="X814D78347858EC13"></a></p>

<h5>31.10-5 IsOne</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsOne</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;property&nbsp;)</td></tr></table></div>
<p>is <code class="keyw">true</code> if <code class="code"><var class="Arg">elm</var> = One( <var class="Arg">elm</var> )</code>, and <code class="keyw">false</code> otherwise.</p>

<p><a id="X82BDA47282F9BBA7" name="X82BDA47282F9BBA7"></a></p>

<h5>31.10-6 IsZero</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsZero</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;property&nbsp;)</td></tr></table></div>
<p>is <code class="keyw">true</code> if <code class="code"><var class="Arg">elm</var> = Zero( <var class="Arg">elm</var> )</code>, and <code class="keyw">false</code> otherwise.</p>

<p><a id="X7CB5896082D29173" name="X7CB5896082D29173"></a></p>

<h5>31.10-7 IsIdempotent</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsIdempotent</code>( <var class="Arg">elt</var> )</td><td class="tdright">(&nbsp;property&nbsp;)</td></tr></table></div>
<p>returns <code class="keyw">true</code> iff <var class="Arg">elt</var> is its own square. (Even if <code class="func">IsZero</code> (<a href="chap31.html#X82BDA47282F9BBA7"><span class="RefLink">31.10-6</span></a>) returns <code class="keyw">true</code> for <var class="Arg">elt</var>.)</p>

<p><a id="X78EE524E83624057" name="X78EE524E83624057"></a></p>

<h5>31.10-8 InverseImmutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseImmutable</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseAttr</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Inverse</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseMutable</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseOp</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseSameMutability</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseSM</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p><code class="func">InverseImmutable</code>, <code class="func">InverseMutable</code>, and <code class="func">InverseSameMutability</code> all return the multiplicative inverse of an element <var class="Arg">elm</var>, that is, an element <var class="Arg">inv</var> such that <code class="code"><var class="Arg">elm</var> * <var class="Arg">inv</var> = <var class="Arg">inv</var> * <var class="Arg">elm</var> = One( <var class="Arg">elm</var> )</code> holds; if <var class="Arg">elm</var> is not invertible then <code class="keyw">fail</code> (see <a href="chap20.html#X85E648AA8414F303"><span class="RefLink">20.2</span></a>) is returned.</p>

<p>Note that the above definition implies that a (general) mapping is invertible in the sense of <code class="func">Inverse</code> only if its source equals its range (see <a href="chap32.html#X7D6F78587C00CDD0"><span class="RefLink">32.14</span></a>). For a bijective mapping <span class="SimpleMath">f</span> whose source and range differ, <code class="func">InverseGeneralMapping</code> (<a href="chap32.html#X865FC25A87D36F3D"><span class="RefLink">32.2-3</span></a>) can be used to construct a mapping <span class="SimpleMath">g</span> with the property that <span class="SimpleMath">f</span> <code class="code">*</code> <span class="SimpleMath">g</span> is the identity mapping on the source of <span class="SimpleMath">f</span> and <span class="SimpleMath">g</span> <code class="code">*</code> <span class="SimpleMath">f</span> is the identity mapping on the range of <span class="SimpleMath">f</span>.</p>

<p>The operations differ only w.r.t. the mutability of the result. <code class="func">InverseImmutable</code> is an attribute and hence returns an immutable result. <code class="func">InverseMutable</code> is guaranteed to return a new <em>mutable</em> object whenever a mutable version of the required element exists in <strong class="pkg">GAP</strong>. <code class="func">InverseSameMutability</code> returns a result that is mutable if <var class="Arg">elm</var> is mutable and if a mutable version of the required element exists in <strong class="pkg">GAP</strong>; for lists, it returns a result of the same immutability level as the argument. For instance, if the argument is a mutable matrix with immutable rows, it returns a similar object.</p>

<p><code class="code">InverseSameMutability( <var class="Arg">elm</var> )</code> is equivalent to <code class="code"><var class="Arg">elm</var>^-1</code>.</p>

<p><code class="func">InverseAttr</code> and <code class="func">Inverse</code> are synonyms of <code class="func">InverseImmutable</code>. <code class="func">InverseSM</code> is a synonym of <code class="func">InverseSameMutability</code>. <code class="func">InverseOp</code> is a synonym of <code class="func">InverseMutable</code>.</p>

<p>The default method of <code class="func">InverseImmutable</code> calls <code class="func">InverseMutable</code> (note that methods for <code class="func">InverseMutable</code> must <em>not</em> delegate to <code class="func">InverseImmutable</code>); other methods to compute inverses need to be installed only for <code class="func">InverseMutable</code> and (in the case of copyable objects) <code class="func">InverseSameMutability</code>.</p>

<p><a id="X84BB723C81D55D63" name="X84BB723C81D55D63"></a></p>

<h5>31.10-9 AdditiveInverseImmutable</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverseImmutable</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverseAttr</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverse</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverseMutable</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverseOp</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverseSameMutability</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AdditiveInverseSM</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p><code class="func">AdditiveInverseImmutable</code>, <code class="func">AdditiveInverseMutable</code>, and <code class="func">AdditiveInverseSameMutability</code> all return the additive inverse of <var class="Arg">elm</var>.</p>

<p>They differ only w.r.t. the mutability of the result. <code class="func">AdditiveInverseImmutable</code> is an attribute and hence returns an immutable result. <code class="func">AdditiveInverseMutable</code> is guaranteed to return a new <em>mutable</em> object whenever a mutable version of the required element exists in <strong class="pkg">GAP</strong> (see <code class="func">IsCopyable</code> (<a href="chap12.html#X811EFD727EBD1ADC"><span class="RefLink">12.6-1</span></a>)). <code class="func">AdditiveInverseSameMutability</code> returns a result that is mutable if <var class="Arg">elm</var> is mutable and if a mutable version of the required element exists in <strong class="pkg">GAP</strong>; for lists, it returns a result of the same immutability level as the argument. For instance, if the argument is a mutable matrix with immutable rows, it returns a similar object.</p>

<p><code class="code">AdditiveInverseSameMutability( <var class="Arg">elm</var> )</code> is equivalent to <code class="code">-<var class="Arg">elm</var></code>.</p>

<p><code class="func">AdditiveInverseAttr</code> and <code class="func">AdditiveInverse</code> are synonyms of <code class="func">AdditiveInverseImmutable</code>. <code class="func">AdditiveInverseSM</code> is a synonym of <code class="func">AdditiveInverseSameMutability</code>. <code class="func">AdditiveInverseOp</code> is a synonym of <code class="func">AdditiveInverseMutable</code>.</p>

<p>The default method of <code class="func">AdditiveInverse</code> calls <code class="func">AdditiveInverseMutable</code> (note that methods for <code class="func">AdditiveInverseMutable</code> must <em>not</em> delegate to <code class="func">AdditiveInverse</code>); so other methods to compute additive inverses need to be installed only for <code class="func">AdditiveInverseMutable</code> and (in the case of copyable objects) <code class="func">AdditiveInverseSameMutability</code>.</p>

<p><a id="X84F59A2687C62763" name="X84F59A2687C62763"></a></p>

<h5>31.10-10 Order</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Order</code>( <var class="Arg">elm</var> )</td><td class="tdright">(&nbsp;attribute&nbsp;)</td></tr></table></div>
<p>is the multiplicative order of <var class="Arg">elm</var>. This is the smallest positive integer <span class="SimpleMath">n</span> such that <var class="Arg">elm</var> <code class="code">^</code> <span class="SimpleMath">n</span> <code class="code">= One( <var class="Arg">elm</var> )</code> if such an integer exists. If the order is infinite, <code class="func">Order</code> may return the value <code class="func">infinity</code> (<a href="chap18.html#X8511B8DF83324C27"><span class="RefLink">18.2-1</span></a>), but it also might run into an infinite loop trying to test the order.</p>

<p><a id="X7B3BC7BA7BB2646D" name="X7B3BC7BA7BB2646D"></a></p>

<h4>31.11 <span class="Heading">Comparison Operations for Elements</span></h4>

<p>Binary comparison operations have been introduced already in <a href="chap4.html#X7A274A1F8553B7E6"><span class="RefLink">4.12</span></a>. The underlying operations for which methods can be installed are the following.</p>

<p><a id="X7EF67D047F03CA6F" name="X7EF67D047F03CA6F"></a></p>

<h5>31.11-1 <span class="Heading">\= and \&lt;</span></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \=</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \&lt;</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>Note that the comparisons via <code class="code">&lt;&gt;</code>, <code class="code">&lt;=</code>, <code class="code">&gt;</code>, and <code class="code">&gt;=</code> are delegated to the operations <code class="func">\=</code> and <code class="func">\&lt;</code>.</p>

<p>In general, objects in <em>different</em> families cannot be compared with <code class="func">\&lt;</code>. For the reason and for exceptions from this rule, see <a href="chap4.html#X7A274A1F8553B7E6"><span class="RefLink">4.12</span></a>.</p>

<p><a id="X7EFE013B8634D214" name="X7EFE013B8634D214"></a></p>

<h5>31.11-2 CanEasilyCompareElements</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CanEasilyCompareElements</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;property&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CanEasilyCompareElementsFamily</code>( <var class="Arg">fam</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CanEasilySortElements</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;property&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CanEasilySortElementsFamily</code>( <var class="Arg">fam</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<p>For some objects a "normal form" is hard to compute and thus equality of elements of a domain might be expensive to test. Therefore <strong class="pkg">GAP</strong> provides a (slightly technical) property with which an algorithm can test whether an efficient equality test is available for elements of a certain kind.</p>

<p><code class="func">CanEasilyCompareElements</code> indicates whether the elements in the family <var class="Arg">fam</var> of <var class="Arg">obj</var> can be easily compared with <code class="func">\=</code> (<a href="chap31.html#X7EF67D047F03CA6F"><span class="RefLink">31.11-1</span></a>).</p>

<p>The default method for this property is to ask the family of <var class="Arg">obj</var>, the default method for the family is to return <code class="keyw">false</code>.</p>

<p>The ability to compare elements may depend on the successful computation of certain information. (For example for finitely presented groups it might depend on the knowledge of a faithful permutation representation.) This information might change over time and thus it might not be a good idea to store a value <code class="keyw">false</code> too early in a family. Instead the function <code class="func">CanEasilyCompareElementsFamily</code> should be called for the family of <var class="Arg">obj</var> which returns <code class="keyw">false</code> if the value of <code class="func">CanEasilyCompareElements</code> is not known for the family without computing it. (This is in fact what the above mentioned family dispatch does.)</p>

<p>If a family knows ab initio that it can compare elements this property should be set as implied filter <em>and</em> filter for the family (the 3rd and 4th argument of <code class="func">NewFamily</code> (<a href="chap79.html#X7FB4123E7E22137D"><span class="RefLink">79.7-1</span></a>) respectively). This guarantees that code which directly asks the family gets a right answer.</p>

<p>The property <code class="func">CanEasilySortElements</code> and the function <code class="func">CanEasilySortElementsFamily</code> behave exactly in the same way, except that they indicate that objects can be compared via <code class="func">\&lt;</code> (<a href="chap31.html#X7EF67D047F03CA6F"><span class="RefLink">31.11-1</span></a>). This property implies <code class="func">CanEasilyCompareElements</code>, as the ordering must be total.</p>

<p><a id="X7A2914307963E370" name="X7A2914307963E370"></a></p>

<h4>31.12 <span class="Heading">Arithmetic Operations for Elements</span></h4>

<p><em>Binary</em> arithmetic operations have been introduced already in <a href="chap4.html#X7B66C8707B5DE10A"><span class="RefLink">4.13</span></a>. The underlying operations for which methods can be installed are the following.</p>

<p><a id="X8481C9B97B214C23" name="X8481C9B97B214C23"></a></p>

<h5>31.12-1 <span class="Heading">\+, \*, \/, \^, \mod</span></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \+</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \*</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \/</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \^</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; \mod</code>( <var class="Arg">left-expr</var>, <var class="Arg">right-expr</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>For details about special methods for <code class="func">\*</code>, <code class="func">\/</code>, <code class="func">\^</code> and <code class="func">\mod</code>, consult the appropriate index entries for them.</p>

<p><a id="X7A37082878DB3930" name="X7A37082878DB3930"></a></p>

<h5>31.12-2 LeftQuotient</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; LeftQuotient</code>( <var class="Arg">elm1</var>, <var class="Arg">elm2</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>returns the product <code class="code"><var class="Arg">elm1</var>^(-1) * <var class="Arg">elm2</var></code>. For some types of objects (for example permutations) this product can be evaluated more efficiently than by first inverting <var class="Arg">elm1</var> and then forming the product with <var class="Arg">elm2</var>.</p>

<p><a id="X80761843831B468E" name="X80761843831B468E"></a></p>

<h5>31.12-3 Comm</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Comm</code>( <var class="Arg">elm1</var>, <var class="Arg">elm2</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>returns the <em>commutator</em> of <var class="Arg">elm1</var> and <var class="Arg">elm2</var>. The commutator is defined as the product <span class="SimpleMath"><var class="Arg">elm1</var>^{-1} * <var class="Arg">elm2</var>^{-1} * <var class="Arg">elm1</var> * <var class="Arg">elm2</var></span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">a:= (1,3)(4,6);; b:= (1,6,5,4,3,2);;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Comm( a, b );</span>
(1,5,3)(2,6,4)
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LeftQuotient( a, b );</span>
(1,2)(3,6)(4,5)
</pre></div>

<p><a id="X86A62A937A42B82E" name="X86A62A937A42B82E"></a></p>

<h5>31.12-4 LieBracket</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; LieBracket</code>( <var class="Arg">elm1</var>, <var class="Arg">elm2</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>returns the element <code class="code"><var class="Arg">elm1</var> * <var class="Arg">elm2</var> - <var class="Arg">elm2</var> * <var class="Arg">elm1</var></code>.</p>

<p>The addition <code class="func">\+</code> (<a href="chap31.html#X8481C9B97B214C23"><span class="RefLink">31.12-1</span></a>) is assumed to be associative but <em>not</em> assumed to be commutative (see <code class="func">IsAdditivelyCommutative</code> (<a href="chap55.html#X82D471327A9CA960"><span class="RefLink">55.3-1</span></a>)). The multiplication <code class="func">\*</code> (<a href="chap31.html#X8481C9B97B214C23"><span class="RefLink">31.12-1</span></a>) is <em>not</em> assumed to be commutative or associative (see <code class="func">IsCommutative</code> (<a href="chap35.html#X830A4A4C795FBC2D"><span class="RefLink">35.4-9</span></a>), <code class="func">IsAssociative</code> (<a href="chap35.html#X7C83B5A47FD18FB7"><span class="RefLink">35.4-7</span></a>)).</p>

<p><a id="X7E8F1FB87C229BB0" name="X7E8F1FB87C229BB0"></a></p>

<h5>31.12-5 Sqrt</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Sqrt</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p><code class="func">Sqrt</code> returns a square root of <var class="Arg">obj</var>, that is, an object <span class="SimpleMath">x</span> with the property that <span class="SimpleMath">x ⋅ x = <var class="Arg">obj</var></span> holds. If such an <span class="SimpleMath">x</span> is not unique then the choice of <span class="SimpleMath">x</span> depends on the type of <var class="Arg">obj</var>. For example, <code class="func">ER</code> (<a href="chap18.html#X813CF4327C4B4D29"><span class="RefLink">18.4-2</span></a>) is the <code class="func">Sqrt</code> method for rationals (see <code class="func">IsRat</code> (<a href="chap17.html#X7ED018F5794935F7"><span class="RefLink">17.2-1</span></a>)).</p>

<p><a id="X80A2D8A7874B268B" name="X80A2D8A7874B268B"></a></p>

<h4>31.13 <span class="Heading">Relations Between Domains</span></h4>

<p>Domains are often constructed relative to other domains. The probably most usual case is to form a <em>subset</em> of a domain, for example the intersection (see <code class="func">Intersection</code> (<a href="chap30.html#X851069107CACF98E"><span class="RefLink">30.5-2</span></a>)) of two domains, or a Sylow subgroup of a given group (see <code class="func">SylowSubgroup</code> (<a href="chap39.html#X7AA351308787544C"><span class="RefLink">39.13-1</span></a>)).</p>

<p>In such a situation, the new domain can gain knowledge by exploiting that several attributes are maintained under taking subsets. For example, the intersection of an arbitrary domain with a finite domain is clearly finite, a Sylow subgroup of an abelian group is abelian, too, and so on.</p>

<p>Since usually the new domain has access to the knowledge of the old domain(s) only when it is created (see <a href="chap31.html#X7B58FDEF80338DD6"><span class="RefLink">31.8</span></a> for the exception), this is the right moment to take advantage of the subset relation, using <code class="func">UseSubsetRelation</code> (<a href="chap31.html#X7C03098C838ADE40"><span class="RefLink">31.13-1</span></a>).</p>

<p>Analogous relations occur when a <em>factor structure</em> is created from a domain and a subset (see <code class="func">UseFactorRelation</code> (<a href="chap31.html#X78039B628262BFA8"><span class="RefLink">31.13-2</span></a>)), and when a domain <em>isomorphic</em> to a given one is created (see <code class="func">UseIsomorphismRelation</code> (<a href="chap31.html#X839BE6467E8474D9"><span class="RefLink">31.13-3</span></a>)).</p>

<p>The functions <code class="func">InstallSubsetMaintenance</code> (<a href="chap31.html#X863C35007C7AA914"><span class="RefLink">31.13-4</span></a>), <code class="func">InstallIsomorphismMaintenance</code> (<a href="chap31.html#X79F97F0F78D89186"><span class="RefLink">31.13-6</span></a>), and <code class="func">InstallFactorMaintenance</code> (<a href="chap31.html#X7BB7EE5078EF6F47"><span class="RefLink">31.13-5</span></a>) are used to tell <strong class="pkg">GAP</strong> under what conditions an attribute is maintained under taking subsets, or forming factor structures or isomorphic domains. This is used only when a new attribute is created, see <a href="chap79.html#X7A38E7E87CCCEDD1"><span class="RefLink">79.3</span></a>. For the attributes already available, such as <code class="func">IsFinite</code> (<a href="chap30.html#X808A4061809A6E67"><span class="RefLink">30.4-2</span></a>) and <code class="func">IsCommutative</code> (<a href="chap35.html#X830A4A4C795FBC2D"><span class="RefLink">35.4-9</span></a>), the maintenances are already notified.</p>

<p><a id="X7C03098C838ADE40" name="X7C03098C838ADE40"></a></p>

<h5>31.13-1 UseSubsetRelation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; UseSubsetRelation</code>( <var class="Arg">super</var>, <var class="Arg">sub</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>Methods for this operation transfer possibly useful information from the domain <var class="Arg">super</var> to its subset <var class="Arg">sub</var>, and vice versa.</p>

<p><code class="func">UseSubsetRelation</code> is designed to be called automatically whenever substructures of domains are constructed. So the methods must be <em>cheap</em>, and the requirements should be as sharp as possible!</p>

<p>To achieve that <em>all</em> applicable methods are executed, all methods for this operation except the default method must end with <code class="code">TryNextMethod()</code>. This default method deals with the information that is available by the calls of <code class="func">InstallSubsetMaintenance</code> (<a href="chap31.html#X863C35007C7AA914"><span class="RefLink">31.13-4</span></a>) in the <strong class="pkg">GAP</strong> library.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g:= Group( (1,2), (3,4), (5,6) );; h:= Group( (1,2), (3,4) );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsAbelian( g );  HasIsAbelian( h );</span>
true
false
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">UseSubsetRelation( g, h );;  HasIsAbelian( h );  IsAbelian( h );</span>
true
true
</pre></div>

<p><a id="X78039B628262BFA8" name="X78039B628262BFA8"></a></p>

<h5>31.13-2 UseFactorRelation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; UseFactorRelation</code>( <var class="Arg">numer</var>, <var class="Arg">denom</var>, <var class="Arg">factor</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>Methods for this operation transfer possibly useful information from the domain <var class="Arg">numer</var> or its subset <var class="Arg">denom</var> to the domain <var class="Arg">factor</var> that is isomorphic to the factor of <var class="Arg">numer</var> by <var class="Arg">denom</var>, and vice versa. <var class="Arg">denom</var> may be <code class="keyw">fail</code>, for example if <var class="Arg">factor</var> is just known to be a factor of <var class="Arg">numer</var> but <var class="Arg">denom</var> is not available as a <strong class="pkg">GAP</strong> object; in this case those factor relations are used that are installed without special requirements for <var class="Arg">denom</var>.</p>

<p><code class="func">UseFactorRelation</code> is designed to be called automatically whenever factor structures of domains are constructed. So the methods must be <em>cheap</em>, and the requirements should be as sharp as possible!</p>

<p>To achieve that <em>all</em> applicable methods are executed, all methods for this operation except the default method must end with a call to <code class="func">TryNextMethod</code> (<a href="chap78.html#X7EED949B83046A7F"><span class="RefLink">78.4-1</span></a>). This default method deals with the information that is available by the calls of <code class="func">InstallFactorMaintenance</code> (<a href="chap31.html#X7BB7EE5078EF6F47"><span class="RefLink">31.13-5</span></a>) in the <strong class="pkg">GAP</strong> library.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g:= Group( (1,2,3,4), (1,2) );; h:= Group( (1,2,3), (1,2) );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsSolvableGroup( g );  HasIsSolvableGroup( h );</span>
true
false
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">UseFactorRelation(g, Subgroup( g, [ (1,2)(3,4), (1,3)(2,4) ] ), h);;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">HasIsSolvableGroup( h );  IsSolvableGroup( h );</span>
true
true
</pre></div>

<p><a id="X839BE6467E8474D9" name="X839BE6467E8474D9"></a></p>

<h5>31.13-3 UseIsomorphismRelation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; UseIsomorphismRelation</code>( <var class="Arg">old</var>, <var class="Arg">new</var> )</td><td class="tdright">(&nbsp;operation&nbsp;)</td></tr></table></div>
<p>Methods for this operation transfer possibly useful information from the domain <var class="Arg">old</var> to the isomorphic domain <var class="Arg">new</var>.</p>

<p><code class="func">UseIsomorphismRelation</code> is designed to be called automatically whenever isomorphic structures of domains are constructed. So the methods must be <em>cheap</em>, and the requirements should be as sharp as possible!</p>

<p>To achieve that <em>all</em> applicable methods are executed, all methods for this operation except the default method must end with a call to <code class="func">TryNextMethod</code> (<a href="chap78.html#X7EED949B83046A7F"><span class="RefLink">78.4-1</span></a>). This default method deals with the information that is available by the calls of <code class="func">InstallIsomorphismMaintenance</code> (<a href="chap31.html#X79F97F0F78D89186"><span class="RefLink">31.13-6</span></a>) in the <strong class="pkg">GAP</strong> library.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g:= Group( (1,2) );;  h:= Group( [ [ -1 ] ] );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Size( g );  HasSize( h );</span>
2
false
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">UseIsomorphismRelation( g, h );;  HasSize( h );  Size( h );</span>
true
2
</pre></div>

<p><a id="X863C35007C7AA914" name="X863C35007C7AA914"></a></p>

<h5>31.13-4 InstallSubsetMaintenance</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InstallSubsetMaintenance</code>( <var class="Arg">opr</var>, <var class="Arg">super_req</var>, <var class="Arg">sub_req</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<p><var class="Arg">opr</var> must be a property or an attribute. The call of <code class="func">InstallSubsetMaintenance</code> has the effect that for a domain <span class="SimpleMath">D</span> in the filter <var class="Arg">super_req</var>, and a domain <span class="SimpleMath">S</span> in the filter <var class="Arg">sub_req</var>, the call <code class="code">UseSubsetRelation</code><span class="SimpleMath">( D, S )</span> (see <code class="func">UseSubsetRelation</code> (<a href="chap31.html#X7C03098C838ADE40"><span class="RefLink">31.13-1</span></a>)) sets a known value of <var class="Arg">opr</var> for <span class="SimpleMath">D</span> as value of <var class="Arg">opr</var> also for <span class="SimpleMath">S</span>. A typical example for which <code class="func">InstallSubsetMaintenance</code> is applied is given by <var class="Arg">opr</var> <code class="code">= IsFinite</code>, <var class="Arg">super_req</var> <code class="code">= IsCollection and IsFinite</code>, and <var class="Arg">sub_req</var> <code class="code">= IsCollection</code>.</p>

<p>If <var class="Arg">opr</var> is a property and the filter <var class="Arg">super_req</var> lies in the filter <var class="Arg">opr</var> then we can use also the following inverse implication. If <span class="SimpleMath">D</span> is in the filter whose intersection with <var class="Arg">opr</var> is <var class="Arg">super_req</var> and if <span class="SimpleMath">S</span> is in the filter <var class="Arg">sub_req</var>, <span class="SimpleMath">S</span> is a subset of <span class="SimpleMath">D</span>, and the value of <var class="Arg">opr</var> for <span class="SimpleMath">S</span> is <code class="keyw">false</code> then the value of <var class="Arg">opr</var> for <span class="SimpleMath">D</span> is also <code class="keyw">false</code>.</p>

<p><a id="X7BB7EE5078EF6F47" name="X7BB7EE5078EF6F47"></a></p>

<h5>31.13-5 InstallFactorMaintenance</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InstallFactorMaintenance</code>( <var class="Arg">opr</var>, <var class="Arg">numer_req</var>, <var class="Arg">denom_req</var>, <var class="Arg">factor_req</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<p><var class="Arg">opr</var> must be a property or an attribute. The call of <code class="func">InstallFactorMaintenance</code> has the effect that for collections <span class="SimpleMath">N</span>, <span class="SimpleMath">D</span>, <span class="SimpleMath">F</span> in the filters <var class="Arg">numer_req</var>, <var class="Arg">denom_req</var>, and <var class="Arg">factor_req</var>, respectively, the call <code class="code">UseFactorRelation</code><span class="SimpleMath">( N, D, F )</span> (see <code class="func">UseFactorRelation</code> (<a href="chap31.html#X78039B628262BFA8"><span class="RefLink">31.13-2</span></a>)) sets a known value of <var class="Arg">opr</var> for <span class="SimpleMath">N</span> as value of <var class="Arg">opr</var> also for <span class="SimpleMath">F</span>. A typical example for which <code class="func">InstallFactorMaintenance</code> is applied is given by <var class="Arg">opr</var> <code class="code">= IsFinite</code>, <var class="Arg">numer_req</var> <code class="code">= IsCollection and IsFinite</code>, <var class="Arg">denom_req</var> <code class="code">= IsCollection</code>, and <var class="Arg">factor_req</var> <code class="code">= IsCollection</code>.</p>

<p>For the other direction, if <var class="Arg">numer_req</var> involves the filter <var class="Arg">opr</var> then a known <code class="keyw">false</code> value of <var class="Arg">opr</var> for <span class="SimpleMath">F</span> implies a <code class="keyw">false</code> value for <span class="SimpleMath">D</span> provided that <span class="SimpleMath">D</span> lies in the filter obtained from <var class="Arg">numer_req</var> by removing <var class="Arg">opr</var>.</p>

<p>Note that an implication of a factor relation holds in particular for the case of isomorphisms. So one need <em>not</em> install an isomorphism maintained method when a factor maintained method is already installed. For example, <code class="func">UseIsomorphismRelation</code> (<a href="chap31.html#X839BE6467E8474D9"><span class="RefLink">31.13-3</span></a>) will transfer a known <code class="func">IsFinite</code> (<a href="chap30.html#X808A4061809A6E67"><span class="RefLink">30.4-2</span></a>) value because of the installed factor maintained method.</p>

<p><a id="X79F97F0F78D89186" name="X79F97F0F78D89186"></a></p>

<h5>31.13-6 InstallIsomorphismMaintenance</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InstallIsomorphismMaintenance</code>( <var class="Arg">opr</var>, <var class="Arg">old_req</var>, <var class="Arg">new_req</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
<p><var class="Arg">opr</var> must be a property or an attribute. The call of <code class="func">InstallIsomorphismMaintenance</code> has the effect that for a domain <span class="SimpleMath">D</span> in the filter <var class="Arg">old_req</var>, and a domain <span class="SimpleMath">E</span> in the filter <var class="Arg">new_req</var>, the call <code class="code">UseIsomorphismRelation</code><span class="SimpleMath">( D, E )</span> (see <code class="func">UseIsomorphismRelation</code> (<a href="chap31.html#X839BE6467E8474D9"><span class="RefLink">31.13-3</span></a>)) sets a known value of <var class="Arg">opr</var> for <span class="SimpleMath">D</span> as value of <var class="Arg">opr</var> also for <span class="SimpleMath">E</span>. A typical example for which <code class="func">InstallIsomorphismMaintenance</code> is applied is given by <var class="Arg">opr</var> <code class="code">= Size</code>, <var class="Arg">old_req</var> <code class="code">= IsCollection</code>, and <var class="Arg">new_req</var> <code class="code">= IsCollection</code>.</p>

<p><a id="X7B97A0307EA161E5" name="X7B97A0307EA161E5"></a></p>

<h4>31.14 <span class="Heading">Useful Categories of Elements</span></h4>

<p>This section and the following one are rather technical, and may be interesting only for those <strong class="pkg">GAP</strong> users who want to implement new kinds of elements.</p>

<p>It deals with certain categories of elements that are useful mainly for the design of elements, from the viewpoint that one wants to form certain domains of these elements. For example, a domain closed under multiplication <code class="code">*</code> (a so-called magma, see Chapter <a href="chap35.html#X873E502F7D21C39C"><span class="RefLink">35</span></a>) makes sense only if its elements can be multiplied, and the latter is indicated by the category <code class="func">IsMultiplicativeElement</code> (<a href="chap31.html#X797D3B2A7A2B2F53"><span class="RefLink">31.14-10</span></a>) for each element. Again note that the underlying idea is that a domain is regarded as <em>generated</em> by given elements, and that these elements carry information about the desired domain. For general information on categories and their hierarchies, see <a href="chap13.html#X7CC6903E78F24167"><span class="RefLink">13.3</span></a>.</p>

<p>More special categories of this kind are described in the contexts where they arise, they are <code class="func">IsRowVector</code> (<a href="chap23.html#X7DFB22A07836A7A9"><span class="RefLink">23.1-1</span></a>), <code class="func">IsMatrix</code> (<a href="chap24.html#X7E1AE46B862B185F"><span class="RefLink">24.2-1</span></a>), <code class="func">IsOrdinaryMatrix</code> (<a href="chap24.html#X7CF42B8A845BC6A9"><span class="RefLink">24.2-2</span></a>), and <code class="func">IsLieMatrix</code> (<a href="chap24.html#X86EC33E17DD12D0E"><span class="RefLink">24.2-3</span></a>).</p>

<p><a id="X7FBD4F65861C2DF2" name="X7FBD4F65861C2DF2"></a></p>

<h5>31.14-1 IsExtAElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsExtAElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An <em>external additive element</em> is an object that can be added via <code class="code">+</code> with other elements (not necessarily in the same family, see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>).</p>

<p><a id="X7F346AA47AEC39AB" name="X7F346AA47AEC39AB"></a></p>

<h5>31.14-2 IsNearAdditiveElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsNearAdditiveElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>near-additive element</em> is an object that can be added via <code class="code">+</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>); this addition is not necessarily commutative.</p>

<p><a id="X78D042B486E1D7F7" name="X78D042B486E1D7F7"></a></p>

<h5>31.14-3 IsAdditiveElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditiveElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An <em>additive element</em> is an object that can be added via <code class="code">+</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>); this addition is commutative.</p>

<p><a id="X7CE2353F836F6E0A" name="X7CE2353F836F6E0A"></a></p>

<h5>31.14-4 IsNearAdditiveElementWithZero</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsNearAdditiveElementWithZero</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>near-additive element-with-zero</em> is an object that can be added via <code class="code">+</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>), and that is an admissible argument for the operation <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442"><span class="RefLink">31.10-3</span></a>); this addition is not necessarily commutative.</p>

<p><a id="X87F3552A789C572D" name="X87F3552A789C572D"></a></p>

<h5>31.14-5 IsAdditiveElementWithZero</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditiveElementWithZero</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An <em>additive element-with-zero</em> is an object that can be added via <code class="code">+</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>), and that is an admissible argument for the operation <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442"><span class="RefLink">31.10-3</span></a>); this addition is commutative.</p>

<p><a id="X84B0929982B51CB4" name="X84B0929982B51CB4"></a></p>

<h5>31.14-6 IsNearAdditiveElementWithInverse</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsNearAdditiveElementWithInverse</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>near-additive element-with-inverse</em> is an object that can be added via <code class="code">+</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>), and that is an admissible argument for the operations <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442"><span class="RefLink">31.10-3</span></a>) and <code class="func">AdditiveInverse</code> (<a href="chap31.html#X84BB723C81D55D63"><span class="RefLink">31.10-9</span></a>); this addition is not necessarily commutative.</p>

<p><a id="X7C0E4AE883947778" name="X7C0E4AE883947778"></a></p>

<h5>31.14-7 IsAdditiveElementWithInverse</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditiveElementWithInverse</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An <em>additive element-with-inverse</em> is an object that can be added via <code class="code">+</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>), and that is an admissible argument for the operations <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442"><span class="RefLink">31.10-3</span></a>) and <code class="func">AdditiveInverse</code> (<a href="chap31.html#X84BB723C81D55D63"><span class="RefLink">31.10-9</span></a>); this addition is commutative.</p>

<p><a id="X860D1E387DD5CCCF" name="X860D1E387DD5CCCF"></a></p>

<h5>31.14-8 IsExtLElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsExtLElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An <em>external left element</em> is an object that can be multiplied from the left, via <code class="code">*</code>, with other elements (not necessarily in the same family, see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>).</p>

<p><a id="X809E0C097E480AF1" name="X809E0C097E480AF1"></a></p>

<h5>31.14-9 IsExtRElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsExtRElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An <em>external right element</em> is an object that can be multiplied from the right, via <code class="code">*</code>, with other elements (not necessarily in the same family, see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>).</p>

<p><a id="X797D3B2A7A2B2F53" name="X797D3B2A7A2B2F53"></a></p>

<h5>31.14-10 IsMultiplicativeElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsMultiplicativeElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>multiplicative element</em> is an object that can be multiplied via <code class="code">*</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>).</p>

<p><a id="X82BC294F7D388AE8" name="X82BC294F7D388AE8"></a></p>

<h5>31.14-11 IsMultiplicativeElementWithOne</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsMultiplicativeElementWithOne</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>multiplicative element-with-one</em> is an object that can be multiplied via <code class="code">*</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>), and that is an admissible argument for the operation <code class="func">One</code> (<a href="chap31.html#X8046262384895B2A"><span class="RefLink">31.10-2</span></a>).</p>

<p><a id="X8703BFC2841BBD63" name="X8703BFC2841BBD63"></a></p>

<h5>31.14-12 IsMultiplicativeElementWithZero</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsMultiplicativeElementWithZero</code>( <var class="Arg">elt</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>Returns: <code class="keyw">true</code> or <code class="keyw">false</code>.</p>

<p>This is the category of elements in a family which can be the operands of <code class="code">*</code> (multiplication) and the operation <code class="func">MultiplicativeZero</code> (<a href="chap35.html#X7B39F93C8136D642"><span class="RefLink">35.4-11</span></a>).</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">S:=Semigroup(Transformation( [ 1, 1, 1 ] ));;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">M:=MagmaWithZeroAdjoined(S);</span>
&lt;&lt;commutative transformation semigroup of degree 3 with 1 generator&gt;
  with 0 adjoined&gt;
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">x:=Representative(M);</span>
&lt;semigroup with 0 adjoined elt: Transformation( [ 1, 1, 1 ] )&gt;
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsMultiplicativeElementWithZero(x);</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">MultiplicativeZeroOp(x);</span>
&lt;semigroup with 0 adjoined elt: 0&gt;
</pre></div>

<p><a id="X7FDB14E57814FA3B" name="X7FDB14E57814FA3B"></a></p>

<h5>31.14-13 IsMultiplicativeElementWithInverse</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsMultiplicativeElementWithInverse</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>multiplicative element-with-inverse</em> is an object that can be multiplied via <code class="code">*</code> with elements in its family (see <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>), and that is an admissible argument for the operations <code class="func">One</code> (<a href="chap31.html#X8046262384895B2A"><span class="RefLink">31.10-2</span></a>) and <code class="func">Inverse</code> (<a href="chap31.html#X78EE524E83624057"><span class="RefLink">31.10-8</span></a>). (Note the word "admissible": an object in this category does not necessarily have an inverse, <code class="func">Inverse</code> (<a href="chap31.html#X78EE524E83624057"><span class="RefLink">31.10-8</span></a>) may return <code class="keyw">fail</code>.)</p>

<p><a id="X802F34F280B29DF4" name="X802F34F280B29DF4"></a></p>

<h5>31.14-14 IsVector</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsVector</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>A <em>vector</em> is an additive-element-with-inverse that can be multiplied from the left and right with other objects (not necessarily of the same type). Examples are cyclotomics, finite field elements, and of course row vectors (see below).</p>

<p>Note that not all lists of ring elements are regarded as vectors, for example lists of matrices are not vectors. This is because although the category <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>) is implied by the meet of its collections category and <code class="func">IsList</code> (<a href="chap21.html#X7C4CC4EA8299701E"><span class="RefLink">21.1-1</span></a>), the family of a list entry may not imply <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>) for all its elements.</p>

<p><a id="X799AEDE180C31276" name="X799AEDE180C31276"></a></p>

<h5>31.14-15 IsNearRingElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsNearRingElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p><code class="func">IsNearRingElement</code> is just a synonym for the meet of <code class="func">IsNearAdditiveElementWithInverse</code> (<a href="chap31.html#X84B0929982B51CB4"><span class="RefLink">31.14-6</span></a>) and <code class="func">IsMultiplicativeElement</code> (<a href="chap31.html#X797D3B2A7A2B2F53"><span class="RefLink">31.14-10</span></a>).</p>

<p><a id="X84BF40CA86C07361" name="X84BF40CA86C07361"></a></p>

<h5>31.14-16 IsRingElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsRingElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p><code class="func">IsRingElement</code> is just a synonym for the meet of <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>) and <code class="func">IsMultiplicativeElement</code> (<a href="chap31.html#X797D3B2A7A2B2F53"><span class="RefLink">31.14-10</span></a>).</p>

<p><a id="X7C724689784EEF3D" name="X7C724689784EEF3D"></a></p>

<h5>31.14-17 IsNearRingElementWithOne</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsNearRingElementWithOne</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p><code class="func">IsNearRingElementWithOne</code> is just a synonym for the meet of <code class="func">IsNearAdditiveElementWithInverse</code> (<a href="chap31.html#X84B0929982B51CB4"><span class="RefLink">31.14-6</span></a>) and <code class="func">IsMultiplicativeElementWithOne</code> (<a href="chap31.html#X82BC294F7D388AE8"><span class="RefLink">31.14-11</span></a>).</p>

<p><a id="X875B67208017608E" name="X875B67208017608E"></a></p>

<h5>31.14-18 IsRingElementWithOne</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsRingElementWithOne</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p><code class="func">IsRingElementWithOne</code> is just a synonym for the meet of <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>) and <code class="func">IsMultiplicativeElementWithOne</code> (<a href="chap31.html#X82BC294F7D388AE8"><span class="RefLink">31.14-11</span></a>).</p>

<p><a id="X80CD04ED85B6B2F9" name="X80CD04ED85B6B2F9"></a></p>

<h5>31.14-19 IsNearRingElementWithInverse</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsNearRingElementWithInverse</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p><code class="func">IsNearRingElementWithInverse</code> is just a synonym for the meet of <code class="func">IsNearAdditiveElementWithInverse</code> (<a href="chap31.html#X84B0929982B51CB4"><span class="RefLink">31.14-6</span></a>) and <code class="func">IsMultiplicativeElementWithInverse</code> (<a href="chap31.html#X7FDB14E57814FA3B"><span class="RefLink">31.14-13</span></a>).</p>

<p><a id="X8113834E84FD0435" name="X8113834E84FD0435"></a></p>

<h5>31.14-20 IsRingElementWithInverse</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsRingElementWithInverse</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsScalar</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p><code class="func">IsRingElementWithInverse</code> and <code class="func">IsScalar</code> are just synonyms for the meet of <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>) and <code class="func">IsMultiplicativeElementWithInverse</code> (<a href="chap31.html#X7FDB14E57814FA3B"><span class="RefLink">31.14-13</span></a>).</p>

<p><a id="X7ABEF00C870789D2" name="X7ABEF00C870789D2"></a></p>

<h4>31.15 <span class="Heading">Useful Categories for all Elements of a Family</span></h4>

<p>The following categories of elements are to be understood mainly as categories for all objects in a family, they are usually used as third argument of <code class="code">NewFamily</code> (see <a href="chap79.html#X8401A9367E8CAA37"><span class="RefLink">79.7</span></a>). The purpose of each of the following categories is then to guarantee that each collection of its elements automatically lies in its collections category (see <code class="func">CategoryCollections</code> (<a href="chap30.html#X78C38017804B2EA7"><span class="RefLink">30.2-4</span></a>)).</p>

<p>For example, the multiplication of permutations is associative, and it is stored in the family of permutations that each permutation lies in <code class="func">IsAssociativeElement</code> (<a href="chap31.html#X7979AFAA80FF795A"><span class="RefLink">31.15-1</span></a>). As a consequence, each magma consisting of permutations (more precisely: each collection that lies in the family <code class="code">CollectionsFamily( PermutationsFamily )</code>, see <code class="func">CollectionsFamily</code> (<a href="chap30.html#X84E5A67E87D8DD66"><span class="RefLink">30.2-1</span></a>)) automatically lies in <code class="code">CategoryCollections( IsAssociativeElement )</code>. A magma in this category is always known to be associative, via a logical implication (see <a href="chap78.html#X7FB5016E83DB4349"><span class="RefLink">78.7</span></a>).</p>

<p>Similarly, if a family knows that all its elements are in the categories <code class="func">IsJacobianElement</code> (<a href="chap31.html#X796957D0805A0221"><span class="RefLink">31.15-5</span></a>) and <code class="func">IsZeroSquaredElement</code> (<a href="chap31.html#X7844399D7847AB24"><span class="RefLink">31.15-6</span></a>), then each algebra of these elements is automatically known to be a Lie algebra (see Chapter <a href="chap62.html#X7DDBF6F47A2E021C"><span class="RefLink">62</span></a>).</p>

<p><a id="X7979AFAA80FF795A" name="X7979AFAA80FF795A"></a></p>

<h5>31.15-1 IsAssociativeElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAssociativeElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAssociativeElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAssociativeElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An element <var class="Arg">obj</var> in the category <code class="func">IsAssociativeElement</code> knows that the multiplication of any elements in the family of <var class="Arg">obj</var> is associative. For example, all permutations lie in this category, as well as those ordinary matrices (see <code class="func">IsOrdinaryMatrix</code> (<a href="chap24.html#X7CF42B8A845BC6A9"><span class="RefLink">24.2-2</span></a>)) whose entries are also in <code class="func">IsAssociativeElement</code>.</p>

<p><a id="X78A286418205CE44" name="X78A286418205CE44"></a></p>

<h5>31.15-2 IsAdditivelyCommutativeElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditivelyCommutativeElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditivelyCommutativeElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditivelyCommutativeElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsAdditivelyCommutativeElementFamily</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An element <var class="Arg">obj</var> in the category <code class="func">IsAdditivelyCommutativeElement</code> knows that the addition of any elements in the family of <var class="Arg">obj</var> is commutative. For example, each finite field element and each rational number lies in this category.</p>

<p><a id="X8137FA8D86714AC0" name="X8137FA8D86714AC0"></a></p>

<h5>31.15-3 IsCommutativeElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsCommutativeElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsCommutativeElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsCommutativeElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An element <var class="Arg">obj</var> in the category <code class="func">IsCommutativeElement</code> knows that the multiplication of any elements in the family of <var class="Arg">obj</var> is commutative. For example, each finite field element and each rational number lies in this category.</p>

<p><a id="X810D2E5E832594AA" name="X810D2E5E832594AA"></a></p>

<h5>31.15-4 IsFiniteOrderElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsFiniteOrderElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsFiniteOrderElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsFiniteOrderElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An element <var class="Arg">obj</var> in the category <code class="func">IsFiniteOrderElement</code> knows that it has finite multiplicative order. For example, each finite field element and each permutation lies in this category. However the value may be <code class="keyw">false</code> even if <var class="Arg">obj</var> has finite order, but if this was not known when <var class="Arg">obj</var> was constructed.</p>

<p>Although it is legal to set this filter for any object with finite order, this is really useful only in the case that all elements of a family are known to have finite order.</p>

<p><a id="X796957D0805A0221" name="X796957D0805A0221"></a></p>

<h5>31.15-5 IsJacobianElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsJacobianElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsJacobianElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsJacobianElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsRestrictedJacobianElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsRestrictedJacobianElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsRestrictedJacobianElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An element <var class="Arg">obj</var> in the category <code class="func">IsJacobianElement</code> knows that the multiplication of any elements in the family <span class="SimpleMath">F</span> of <var class="Arg">obj</var> satisfies the Jacobi identity, that is, <span class="SimpleMath">x * y * z + z * x * y + y * z * x</span> is zero for all <span class="SimpleMath">x</span>, <span class="SimpleMath">y</span>, <span class="SimpleMath">z</span> in <span class="SimpleMath">F</span>.</p>

<p>For example, each Lie matrix (see <code class="func">IsLieMatrix</code> (<a href="chap24.html#X86EC33E17DD12D0E"><span class="RefLink">24.2-3</span></a>)) lies in this category.</p>

<p><a id="X7844399D7847AB24" name="X7844399D7847AB24"></a></p>

<h5>31.15-6 IsZeroSquaredElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsZeroSquaredElement</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsZeroSquaredElementCollection</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsZeroSquaredElementCollColl</code>( <var class="Arg">obj</var> )</td><td class="tdright">(&nbsp;category&nbsp;)</td></tr></table></div>
<p>An element <var class="Arg">obj</var> in the category <code class="func">IsZeroSquaredElement</code> knows that <code class="code"><var class="Arg">obj</var>^2 = Zero( <var class="Arg">obj</var> )</code>. For example, each Lie matrix (see <code class="func">IsLieMatrix</code> (<a href="chap24.html#X86EC33E17DD12D0E"><span class="RefLink">24.2-3</span></a>)) lies in this category.</p>

<p>Although it is legal to set this filter for any zero squared object, this is really useful only in the case that all elements of a family are known to have square zero.</p>


<div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp;  <a href="chap0.html#contents">[Contents]</a>&nbsp;  &nbsp;<a href="chap30.html">[Previous Chapter]</a>&nbsp;  &nbsp;<a href="chap32.html">[Next Chapter]</a>&nbsp;  </div>


<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chap16.html">16</a>  <a href="chap17.html">17</a>  <a href="chap18.html">18</a>  <a href="chap19.html">19</a>  <a href="chap20.html">20</a>  <a href="chap21.html">21</a>  <a href="chap22.html">22</a>  <a href="chap23.html">23</a>  <a href="chap24.html">24</a>  <a href="chap25.html">25</a>  <a href="chap26.html">26</a>  <a href="chap27.html">27</a>  <a href="chap28.html">28</a>  <a href="chap29.html">29</a>  <a href="chap30.html">30</a>  <a href="chap31.html">31</a>  <a href="chap32.html">32</a>  <a href="chap33.html">33</a>  <a href="chap34.html">34</a>  <a href="chap35.html">35</a>  <a href="chap36.html">36</a>  <a href="chap37.html">37</a>  <a href="chap38.html">38</a>  <a href="chap39.html">39</a>  <a href="chap40.html">40</a>  <a href="chap41.html">41</a>  <a href="chap42.html">42</a>  <a href="chap43.html">43</a>  <a href="chap44.html">44</a>  <a href="chap45.html">45</a>  <a href="chap46.html">46</a>  <a href="chap47.html">47</a>  <a href="chap48.html">48</a>  <a href="chap49.html">49</a>  <a href="chap50.html">50</a>  <a href="chap51.html">51</a>  <a href="chap52.html">52</a>  <a href="chap53.html">53</a>  <a href="chap54.html">54</a>  <a href="chap55.html">55</a>  <a href="chap56.html">56</a>  <a href="chap57.html">57</a>  <a href="chap58.html">58</a>  <a href="chap59.html">59</a>  <a href="chap60.html">60</a>  <a href="chap61.html">61</a>  <a href="chap62.html">62</a>  <a href="chap63.html">63</a>  <a href="chap64.html">64</a>  <a href="chap65.html">65</a>  <a href="chap66.html">66</a>  <a href="chap67.html">67</a>  <a href="chap68.html">68</a>  <a href="chap69.html">69</a>  <a href="chap70.html">70</a>  <a href="chap71.html">71</a>  <a href="chap72.html">72</a>  <a href="chap73.html">73</a>  <a href="chap74.html">74</a>  <a href="chap75.html">75</a>  <a href="chap76.html">76</a>  <a href="chap77.html">77</a>  <a href="chap78.html">78</a>  <a href="chap79.html">79</a>  <a href="chap80.html">80</a>  <a href="chap81.html">81</a>  <a href="chap82.html">82</a>  <a href="chap83.html">83</a>  <a href="chap84.html">84</a>  <a href="chap85.html">85</a>  <a href="chap86.html">86</a>  <a href="chap87.html">87</a>  <a href="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>