GeneratorsOfMagma for a quandle generated by ConjugatorObjs

gap/byconj.gd

@@ -12,10 +12,12 @@ DeclareAttribute("ConjugatorFamily", IsFamily);
 DeclareSynonym("IsDefaultConjugatorObject",
                IsConjugatorObject and IsPositionalObjectOneSlotRep);
 
-DeclareAttribute("ConjugatorObj", 
-                 IsMultiplicativeElement and IsLeftQuotientElement and
-                 IsRightQuotientElement
-                );
+# As far as I can tell, we are not losing any generality here;
+# to define the conjugator, we need the quotient on one side, to define
+# left quotients of conjugators we need the quotient on the other side, and
+# to prove it works we need associativity, which makes the underlying elements
+# of conjugator objects automatically group elements.
+DeclareAttribute("ConjugatorObj", IsMultiplicativeElementWithInverse);
 
 DeclareAttribute("UnderlyingMultiplicativeElement", IsConjugatorObject);
 

gap/byconj.gi

@@ -17,20 +17,8 @@ ConjugatorType@ := obj -> ConjugatorFamily(FamilyObj(obj))!.ConjType;
 
 InstallMethod(ConjugatorObj,
   "for a mult element that allows quotients (and should be assoc)",
-  [IsMultiplicativeElement and IsLeftQuotientElement and IsRightQuotientElement],
-  obj -> Objectify(ConjugatorType@(obj), Immutable(obj))
-);
-
-# Even though IsMultiplicativeElementWithInverse implies both
-# IsLeftQuotientElement and IsRightQuotientElement, GAP doesn't seem to
-# calculate these implications on built-in elements. So we need to repeat the
-# method for IsMultiplicativeElementWithInverse, which is true of built-ins,
-# particularly permutations, which serve as a common representation of group
-# elements.
-InstallMethod(ConjugatorObj,
-  "for a mult element with inverse (and should be assoc)",
   [IsMultiplicativeElementWithInverse],
-  obj -> Objectify(ConjugatorType@(obj), [Immutable(obj)])
+  obj -> Objectify(ConjugatorType@(obj), Immutable(obj))
 );
 
 ## Printing and viewing
@@ -78,7 +66,7 @@ InstallMethod(ConjugationQuandle, "for a group",
   function(G)
     local fam, elts, Q;
     fam := CollectionsFamily(ConjugatorFamily(ElementsFamily(FamilyObj(G))));
-    # Question: how do we easily/quickly determine a set of generators of
+    # Question: how do we feasibly determine a set of generators of
     # Conj(G) from a set of generators of G, so that we can handle infinite
     # conj-quandles here?
     elts := List(Elements(G), g -> ConjugatorObj(g) );
@@ -92,6 +80,19 @@ InstallMethod(ConjugationQuandle, "for a group",
     return Q;
 end);
 
+## Methods that are easier in conjugator quandles:
 
+InstallMethod(GeneratorsOfMagma,
+  "for a quandle generated by conjugator objects",            
+  [IsLeftQuasigroup and HasGeneratorsOfLeftQuasigroup and
+   IsConjugatorObjectCollection],
+  function(Q)
+    local gens, invgens;
+    # idea: ^g^-1: * ^h: = ^g: \ ^h:, so the generators of the quasigroup
+    # together with their inverses generate the quandle as a magma.
+    gens := GeneratorsOfLeftQuasigroup(Q);
+    invgens := Set(gens, g -> Inverse(g));
+    UniteSet(invgens, gens);
+    return invgens;
+end);
 
-              

gap/structure.gd

@@ -74,7 +74,7 @@ DeclareGlobalFunction("CloneOfTypeByGenerators");
 # elements might be required to generate the structure just under *
 DeclareAttribute("GeneratorsOfLeftQuasigroup", IsLeftQuasigroup);
 InstallImmediateMethod(GeneratorsOfMagma,
-  "finite left quasigroups *-generated by left quasigroup generators",
+  "finite left quasigroups"
   IsLeftQuasigroup and IsFinite,
   1,
   q -> GeneratorsOfLeftQuasigroup(q)
@@ -83,7 +83,7 @@ InstallImmediateMethod(GeneratorsOfMagma,
 # Generates the structure by \* and \/, same considerations as above
 DeclareAttribute("GeneratorsOfRightQuasigroup", IsRightQuasigroup);
 InstallImmediateMethod(GeneratorsOfMagma,
-  "finite right quasigroups *-generated by right quasigroup generators",
+  "finite right quasigroups"
   IsRightQuasigroup and IsFinite,
   2,
   q -> GeneratorsOfRightQuasigroup(q)

gap/structure.gi

@@ -8,8 +8,8 @@ InstallMethod(IsElementwiseIdempotent, "for finite collections",
 );
 
 InstallMethod(IsLSelfDistributive,
-              "for arbitrary multiplicative collections, the hard way",
-              [IsMultiplicativeElementCollection],
+  "for arbitrary multiplicative collections, the hard way",
+  [IsMultiplicativeElementCollection],
   function (C)
     local a,b,d;
     for a in C do for b in C do for d in C do
@@ -19,8 +19,8 @@ InstallMethod(IsLSelfDistributive,
 end);
 
 InstallMethod(IsRSelfDistributive,
-              "for arbitrary multiplicative collections, the hard way",
-              [IsMultiplicativeElementCollection],
+  "for arbitrary multiplicative collections, the hard way",
+  [IsMultiplicativeElementCollection],
   function (C)
     local a,b,d;
     for a in C do for b in C do for d in C do
@@ -172,6 +172,12 @@ InstallGlobalFunction(RightQuandleNC, function(fam, gens)
                                  RightQuandleByMultiplicationTableNC);
 end);
 
+## NOTE: If it is the case that the magma generated by the
+## GeneratorsOf[Left|Right]Quasigroup is finite, then since the [left|right]
+## multiplication is injective, it is also surjective on that set and in fact
+## it is the whole quasigroup. However, it is not yet clear to me how best to
+## capture this fact in GAP in a computationally useful way.
+
 ## View and print and such
 LeftObjString@ := function(Q)
   # Don't test distributivity if we haven't already